<html>
<head><script>
var $gwt_version = "2.0.0";
var $wnd = parent;
var $doc = $wnd.document;
var $moduleName, $moduleBase;
var $strongName = 'BF409E757DD6E22AD60B78A13345A447';
var $stats = $wnd.__gwtStatsEvent ? function(a) {return $wnd.__gwtStatsEvent(a);} : null,
$sessionId = $wnd.__gwtStatsSessionId ? $wnd.__gwtStatsSessionId : null;
$stats && $stats({moduleName:'JBHelloWorld',sessionId:$sessionId,subSystem:'startup',evtGroup:'moduleStartup',millis:(new Date()).getTime(),type:'moduleEvalStart'});
</script></head>
<body>
<script><!--
var _, N8000000000000000_longLit = [0, -9223372036854775808], P0_longLit = [0, 0], P2_longLit = [2, 0], P4_longLit = [4, 0], P10_longLit = [16, 0], P100_longLit = [256, 0], P3e8_longLit = [1000, 0], P10000_longLit = [65536, 0], P1000000_longLit = [16777216, 0], P7fffffffffffffff_longLit = [4294967295, 9223372032559808512];
function nullMethod(){
}

function equals(other){
  return this === (other == null?null:other);
}

function getClass_0(){
  return Ljava_lang_Object_2_classLit;
}

function hashCode_0(){
  return this.$H || (this.$H = ++sNextHashId);
}

function toString_0(){
  return (this.typeMarker$ == nullMethod || this.typeId$ == 2?this.getClass$():Lcom_google_gwt_core_client_JavaScriptObject_2_classLit).typeName + '@' + toPowerOfTwoString(this.typeMarker$ == nullMethod || this.typeId$ == 2?this.hashCode$():this.$H || (this.$H = ++sNextHashId), 4);
}

function Object_0(){
}

_ = Object_0.prototype = {};
_.equals$ = equals;
_.getClass$ = getClass_0;
_.hashCode$ = hashCode_0;
_.toString$ = toString_0;
_.toString = function(){
  return this.toString$();
}
;
_.typeMarker$ = nullMethod;
_.typeId$ = 1;
var gContactDestroyedCallback = null;
function $clinit_1(){
  $clinit_1 = nullMethod;
  $Vector3f_2(new Vector3f);
  gProfileClock = $Clock(new Clock);
}

var gAddedPairs = 0, gNumDeepPenetrationChecks = 0, gNumGjkChecks = 0, gProfileClock, gRemovePairs = 0, stepSimulationTime = P0_longLit;
function $AxisSweep3Internal(this$static, worldAabbMin, worldAabbMax, handleMask, handleSentinel, userMaxHandles, pairCache){
  var aabbSize, axis, i, maxHandles, maxInt;
  this$static.worldAabbMin = $Vector3f_2(new Vector3f);
  this$static.worldAabbMax = $Vector3f_2(new Vector3f);
  this$static.quantize = $Vector3f_2(new Vector3f);
  this$static.pEdges = initDim(_3Lcom_bulletphysics_gwt_client_collision_broadphase_AxisSweep3Internal$EdgeArray_2_classLit, 124, 13, 3, 0);
  this$static.bpHandleMask = handleMask;
  this$static.handleSentinel = handleSentinel;
  this$static.pairCache = pairCache;
  maxHandles = userMaxHandles + 1;
  !this$static.pairCache && (this$static.pairCache = $HashedOverlappingPairCache(new HashedOverlappingPairCache));
  $set_9(this$static.worldAabbMin, worldAabbMin);
  $set_9(this$static.worldAabbMax, worldAabbMax);
  aabbSize = $Vector3f_2(new Vector3f);
  $sub(aabbSize, this$static.worldAabbMax, this$static.worldAabbMin);
  maxInt = this$static.handleSentinel;
  $set_8(this$static.quantize, maxInt / aabbSize.x, maxInt / aabbSize.y, maxInt / aabbSize.z);
  this$static.pHandles = initDim(_3Lcom_bulletphysics_gwt_client_collision_broadphase_AxisSweep3Internal$Handle_2_classLit, 125, 2, maxHandles, 0);
  for (i = 0; i < maxHandles; ++i) {
    setCheck(this$static.pHandles, i, new AxisSweep3$HandleImpl);
  }
  this$static.numHandles = 0;
  this$static.firstFreeHandle = 1;
  for (i = this$static.firstFreeHandle; i < maxHandles; ++i) {
    $setMinEdges(dynamicCast(this$static.pHandles[i], 12), 0, i + 1);
  }
  $setMinEdges(dynamicCast(this$static.pHandles[maxHandles - 1], 12), 0, 0);
  for (i = 0; i < 3; ++i) {
    setCheck(this$static.pEdges, i, $AxisSweep3$EdgeArrayImpl(new AxisSweep3$EdgeArrayImpl, maxHandles * 2));
  }
  this$static.pHandles[0].clientObject = null;
  for (axis = 0; axis < 3; ++axis) {
    $setMinEdges(this$static.pHandles[0], axis, 0);
    $setMaxEdges(this$static.pHandles[0], axis, 1);
    this$static.pEdges[axis].pos[0] = 0 << 16 >> 16;
    this$static.pEdges[axis].handle[0] = 0 << 16 >> 16;
    this$static.pEdges[axis].pos[1] = handleSentinel << 16 >> 16;
    this$static.pEdges[axis].handle[1] = 0 << 16 >> 16;
  }
  this$static.mask = 65535;
  return this$static;
}

function $addHandle(this$static, aabbMin, aabbMax, pOwner, collisionFilterGroup, collisionFilterMask){
  var axis, handle, limit, max, min, pHandle, handle_0;
  min = initDim(_3I_classLit, 150, -1, 3, 1);
  max = initDim(_3I_classLit, 150, -1, 3, 1);
  $quantize(this$static, min, aabbMin, 0);
  $quantize(this$static, max, aabbMax, 1);
  handle = (handle_0 = this$static.firstFreeHandle , this$static.firstFreeHandle = $getMinEdges(dynamicCast(this$static.pHandles[handle_0], 12), 0) , ++this$static.numHandles , handle_0);
  pHandle = dynamicCast(this$static.pHandles[handle], 12);
  pHandle.uniqueId = handle;
  pHandle.clientObject = pOwner;
  pHandle.collisionFilterGroup = collisionFilterGroup;
  pHandle.collisionFilterMask = collisionFilterMask;
  limit = this$static.numHandles * 2;
  for (axis = 0; axis < 3; ++axis) {
    $setMaxEdges(this$static.pHandles[0], axis, $getMaxEdges(this$static.pHandles[0], axis) + 2);
    $set(this$static.pEdges[axis], limit + 1, limit - 1);
    this$static.pEdges[axis].pos[limit - 1] = min[axis] << 16 >> 16;
    this$static.pEdges[axis].handle[limit - 1] = handle << 16 >> 16;
    this$static.pEdges[axis].pos[limit] = max[axis] << 16 >> 16;
    this$static.pEdges[axis].handle[limit] = handle << 16 >> 16;
    $setMinEdges(pHandle, axis, limit - 1);
    $setMaxEdges(pHandle, axis, limit);
  }
  $sortMinDown(this$static, 0, $getMinEdges(pHandle, 0), false);
  $sortMaxDown(this$static, 0, $getMaxEdges(pHandle, 0), false);
  $sortMinDown(this$static, 1, $getMinEdges(pHandle, 1), false);
  $sortMaxDown(this$static, 1, $getMaxEdges(pHandle, 1), false);
  $sortMinDown(this$static, 2, $getMinEdges(pHandle, 2), true);
  $sortMaxDown(this$static, 2, $getMaxEdges(pHandle, 2), true);
  return handle;
}

function $createProxy(this$static, aabbMin, aabbMax, userPtr, collisionFilterGroup, collisionFilterMask){
  var handle, handleId;
  handleId = $addHandle(this$static, aabbMin, aabbMax, userPtr, collisionFilterGroup, collisionFilterMask);
  handle = dynamicCast(this$static.pHandles[handleId], 12);
  return handle;
}

function $quantize(this$static, out, point, isMax){
  var clampedPoint, v;
  clampedPoint = $Vector3f_1(new Vector3f, point);
  setMax(clampedPoint, this$static.worldAabbMin);
  setMin(clampedPoint, this$static.worldAabbMax);
  v = $Vector3f_2(new Vector3f);
  $sub(v, clampedPoint, this$static.worldAabbMin);
  mul(v, v, this$static.quantize);
  out[0] = (~~Math.max(Math.min(v.x, 2147483647), -2147483648) & this$static.bpHandleMask | isMax) & this$static.mask;
  out[1] = (~~Math.max(Math.min(v.y, 2147483647), -2147483648) & this$static.bpHandleMask | isMax) & this$static.mask;
  out[2] = (~~Math.max(Math.min(v.z, 2147483647), -2147483648) & this$static.bpHandleMask | isMax) & this$static.mask;
}

function $setAabb(this$static, proxy, aabbMin, aabbMax){
  var handle;
  handle = proxy;
  $updateHandle(this$static, handle.uniqueId, aabbMin, aabbMax);
}

function $sortMaxDown(this$static, axis, edge, updateOverlaps){
  var edgeArray, handle0, handle1, pEdge_idx, pHandleEdge, pHandlePrev, pPrev_idx;
  edgeArray = this$static.pEdges[axis];
  pEdge_idx = edge;
  pPrev_idx = pEdge_idx - 1;
  pHandleEdge = this$static.pHandles[edgeArray.handle[pEdge_idx] & 65535];
  while ((edgeArray.pos[pEdge_idx] & 65535) < (edgeArray.pos[pPrev_idx] & 65535)) {
    pHandlePrev = this$static.pHandles[edgeArray.handle[pPrev_idx] & 65535];
    if ((edgeArray.pos[pPrev_idx] & 65535 & 1) == 0) {
      if (updateOverlaps) {
        handle0 = this$static.pHandles[edgeArray.handle[pEdge_idx] & 65535];
        handle1 = this$static.pHandles[edgeArray.handle[pPrev_idx] & 65535];
        $removeOverlappingPair(this$static.pairCache, handle0, handle1);
      }
      $setMinEdges(pHandlePrev, axis, $getMinEdges(pHandlePrev, axis) + 1);
    }
     else {
      $setMaxEdges(pHandlePrev, axis, $getMaxEdges(pHandlePrev, axis) + 1);
    }
    $setMaxEdges(pHandleEdge, axis, $getMaxEdges(pHandleEdge, axis) - 1);
    $swap(edgeArray, pEdge_idx, pPrev_idx);
    --pEdge_idx;
    --pPrev_idx;
  }
}

function $sortMaxUp(this$static, axis, edge, updateOverlaps){
  var edgeArray, handle0, handle1, pEdge_idx, pHandleEdge, pHandleNext, pNext_idx;
  edgeArray = this$static.pEdges[axis];
  pEdge_idx = edge;
  pNext_idx = pEdge_idx + 1;
  pHandleEdge = this$static.pHandles[edgeArray.handle[pEdge_idx] & 65535];
  while ((edgeArray.handle[pNext_idx] & 65535) != 0 && (edgeArray.pos[pEdge_idx] & 65535) >= (edgeArray.pos[pNext_idx] & 65535)) {
    pHandleNext = this$static.pHandles[edgeArray.handle[pNext_idx] & 65535];
    if ((edgeArray.pos[pNext_idx] & 65535 & 1) == 0) {
      if (updateOverlaps && $testOverlap(axis, pHandleEdge, pHandleNext)) {
        handle0 = this$static.pHandles[edgeArray.handle[pEdge_idx] & 65535];
        handle1 = this$static.pHandles[edgeArray.handle[pNext_idx] & 65535];
        $addOverlappingPair(this$static.pairCache, handle0, handle1);
      }
      $setMinEdges(pHandleNext, axis, $getMinEdges(pHandleNext, axis) - 1);
    }
     else {
      $setMaxEdges(pHandleNext, axis, $getMaxEdges(pHandleNext, axis) - 1);
    }
    $setMaxEdges(pHandleEdge, axis, $getMaxEdges(pHandleEdge, axis) + 1);
    $swap(edgeArray, pEdge_idx, pNext_idx);
    ++pEdge_idx;
    ++pNext_idx;
  }
}

function $sortMinDown(this$static, axis, edge, updateOverlaps){
  var edgeArray, pEdge_idx, pHandleEdge, pHandlePrev, pPrev_idx;
  edgeArray = this$static.pEdges[axis];
  pEdge_idx = edge;
  pPrev_idx = pEdge_idx - 1;
  pHandleEdge = this$static.pHandles[edgeArray.handle[pEdge_idx] & 65535];
  while ((edgeArray.pos[pEdge_idx] & 65535) < (edgeArray.pos[pPrev_idx] & 65535)) {
    pHandlePrev = this$static.pHandles[edgeArray.handle[pPrev_idx] & 65535];
    if ((edgeArray.pos[pPrev_idx] & 65535 & 1) != 0) {
      updateOverlaps && $testOverlap(axis, pHandleEdge, pHandlePrev) && $addOverlappingPair(this$static.pairCache, pHandleEdge, pHandlePrev);
      $setMaxEdges(pHandlePrev, axis, $getMaxEdges(pHandlePrev, axis) + 1);
    }
     else {
      $setMinEdges(pHandlePrev, axis, $getMinEdges(pHandlePrev, axis) + 1);
    }
    $setMinEdges(pHandleEdge, axis, $getMinEdges(pHandleEdge, axis) - 1);
    $swap(edgeArray, pEdge_idx, pPrev_idx);
    --pEdge_idx;
    --pPrev_idx;
  }
}

function $sortMinUp(this$static, axis, edge, updateOverlaps){
  var edgeArray, handle0, handle1, pEdge_idx, pHandleEdge, pHandleNext, pNext_idx;
  edgeArray = this$static.pEdges[axis];
  pEdge_idx = edge;
  pNext_idx = pEdge_idx + 1;
  pHandleEdge = this$static.pHandles[edgeArray.handle[pEdge_idx] & 65535];
  while ((edgeArray.handle[pNext_idx] & 65535) != 0 && (edgeArray.pos[pEdge_idx] & 65535) >= (edgeArray.pos[pNext_idx] & 65535)) {
    pHandleNext = this$static.pHandles[edgeArray.handle[pNext_idx] & 65535];
    if ((edgeArray.pos[pNext_idx] & 65535 & 1) != 0) {
      if (updateOverlaps) {
        handle0 = this$static.pHandles[edgeArray.handle[pEdge_idx] & 65535];
        handle1 = this$static.pHandles[edgeArray.handle[pNext_idx] & 65535];
        $removeOverlappingPair(this$static.pairCache, handle0, handle1);
      }
      $setMaxEdges(pHandleNext, axis, $getMaxEdges(pHandleNext, axis) - 1);
    }
     else {
      $setMinEdges(pHandleNext, axis, $getMinEdges(pHandleNext, axis) - 1);
    }
    $setMinEdges(pHandleEdge, axis, $getMinEdges(pHandleEdge, axis) + 1);
    $swap(edgeArray, pEdge_idx, pNext_idx);
    ++pEdge_idx;
    ++pNext_idx;
  }
}

function $testOverlap(ignoreAxis, pHandleA, pHandleB){
  var axis;
  for (axis = 0; axis < 3; ++axis) {
    if (axis != ignoreAxis) {
      if ($getMaxEdges(pHandleA, axis) < $getMinEdges(pHandleB, axis) || $getMaxEdges(pHandleB, axis) < $getMinEdges(pHandleA, axis)) {
        return false;
      }
    }
  }
  return true;
}

function $updateHandle(this$static, handle, aabbMin, aabbMax){
  var axis, dmax, dmin, emax, emin, max, min, pHandle;
  pHandle = dynamicCast(this$static.pHandles[handle], 12);
  min = initDim(_3I_classLit, 150, -1, 3, 1);
  max = initDim(_3I_classLit, 150, -1, 3, 1);
  $quantize(this$static, min, aabbMin, 0);
  $quantize(this$static, max, aabbMax, 1);
  for (axis = 0; axis < 3; ++axis) {
    emin = $getMinEdges(pHandle, axis);
    emax = $getMaxEdges(pHandle, axis);
    dmin = min[axis] - (this$static.pEdges[axis].pos[emin] & 65535);
    dmax = max[axis] - (this$static.pEdges[axis].pos[emax] & 65535);
    this$static.pEdges[axis].pos[emin] = min[axis] << 16 >> 16;
    this$static.pEdges[axis].pos[emax] = max[axis] << 16 >> 16;
    dmin < 0 && $sortMinDown(this$static, axis, emin, true);
    dmax > 0 && $sortMaxUp(this$static, axis, emax, true);
    dmin > 0 && $sortMinUp(this$static, axis, emin, true);
    dmax < 0 && $sortMaxDown(this$static, axis, emax, true);
  }
}

function getClass_1(){
  return Lcom_bulletphysics_gwt_client_collision_broadphase_AxisSweep3Internal_2_classLit;
}

function AxisSweep3Internal(){
}

_ = AxisSweep3Internal.prototype = new Object_0;
_.getClass$ = getClass_1;
_.typeId$ = 0;
_.bpHandleMask = 0;
_.firstFreeHandle = 0;
_.handleSentinel = 0;
_.mask = 0;
_.numHandles = 0;
_.pHandles = null;
_.pairCache = null;
function $AxisSweep3(this$static, worldAabbMin, worldAabbMax, maxHandles){
  $AxisSweep3Internal(this$static, worldAabbMin, worldAabbMax, 65534, 65535, maxHandles, null);
  return this$static;
}

function getClass_2(){
  return Lcom_bulletphysics_gwt_client_collision_broadphase_AxisSweep3_2_classLit;
}

function AxisSweep3(){
}

_ = AxisSweep3.prototype = new AxisSweep3Internal;
_.getClass$ = getClass_2;
_.typeId$ = 0;
function getClass_3(){
  return Lcom_bulletphysics_gwt_client_collision_broadphase_AxisSweep3Internal$EdgeArray_2_classLit;
}

function AxisSweep3Internal$EdgeArray(){
}

_ = AxisSweep3Internal$EdgeArray.prototype = new Object_0;
_.getClass$ = getClass_3;
_.typeId$ = 3;
function $AxisSweep3$EdgeArrayImpl(this$static, size){
  this$static.pos = initDim(_3S_classLit, 0, -1, size, 1);
  this$static.handle = initDim(_3S_classLit, 0, -1, size, 1);
  return this$static;
}

function $set(this$static, dest, src){
  this$static.pos[dest] = this$static.pos[src];
  this$static.handle[dest] = this$static.handle[src];
}

function $swap(this$static, idx1, idx2){
  var tmpHandle, tmpPos;
  tmpPos = this$static.pos[idx1];
  tmpHandle = this$static.handle[idx1];
  this$static.pos[idx1] = this$static.pos[idx2];
  this$static.handle[idx1] = this$static.handle[idx2];
  this$static.pos[idx2] = tmpPos;
  this$static.handle[idx2] = tmpHandle;
}

function getClass_4(){
  return Lcom_bulletphysics_gwt_client_collision_broadphase_AxisSweep3$EdgeArrayImpl_2_classLit;
}

function AxisSweep3$EdgeArrayImpl(){
}

_ = AxisSweep3$EdgeArrayImpl.prototype = new AxisSweep3Internal$EdgeArray;
_.getClass$ = getClass_4;
_.typeId$ = 4;
_.handle = null;
_.pos = null;
function getClass_5(){
  return Lcom_bulletphysics_gwt_client_collision_broadphase_BroadphaseProxy_2_classLit;
}

function BroadphaseProxy(){
}

_ = BroadphaseProxy.prototype = new Object_0;
_.getClass$ = getClass_5;
_.typeId$ = 5;
_.clientObject = null;
_.collisionFilterGroup = 0;
_.collisionFilterMask = 0;
_.uniqueId = 0;
function getClass_6(){
  return Lcom_bulletphysics_gwt_client_collision_broadphase_AxisSweep3Internal$Handle_2_classLit;
}

function AxisSweep3Internal$Handle(){
}

_ = AxisSweep3Internal$Handle.prototype = new BroadphaseProxy;
_.getClass$ = getClass_6;
_.typeId$ = 6;
function $getMaxEdges(this$static, edgeIndex){
  switch (edgeIndex) {
    default:case 0:
      return this$static.maxEdges0 & 65535;
    case 1:
      return this$static.maxEdges1 & 65535;
    case 2:
      return this$static.maxEdges2 & 65535;
  }
}

function $getMinEdges(this$static, edgeIndex){
  switch (edgeIndex) {
    default:case 0:
      return this$static.minEdges0 & 65535;
    case 1:
      return this$static.minEdges1 & 65535;
    case 2:
      return this$static.minEdges2 & 65535;
  }
}

function $setMaxEdges(this$static, edgeIndex, value){
  switch (edgeIndex) {
    case 0:
      this$static.maxEdges0 = value << 16 >> 16;
      break;
    case 1:
      this$static.maxEdges1 = value << 16 >> 16;
      break;
    case 2:
      this$static.maxEdges2 = value << 16 >> 16;
  }
}

function $setMinEdges(this$static, edgeIndex, value){
  switch (edgeIndex) {
    case 0:
      this$static.minEdges0 = value << 16 >> 16;
      break;
    case 1:
      this$static.minEdges1 = value << 16 >> 16;
      break;
    case 2:
      this$static.minEdges2 = value << 16 >> 16;
  }
}

function getClass_7(){
  return Lcom_bulletphysics_gwt_client_collision_broadphase_AxisSweep3$HandleImpl_2_classLit;
}

function AxisSweep3$HandleImpl(){
}

_ = AxisSweep3$HandleImpl.prototype = new AxisSweep3Internal$Handle;
_.getClass$ = getClass_7;
_.typeId$ = 7;
_.maxEdges0 = 0;
_.maxEdges1 = 0;
_.maxEdges2 = 0;
_.minEdges0 = 0;
_.minEdges1 = 0;
_.minEdges2 = 0;
function compareTo(p0){
  return this.ordinal - dynamicCast(p0, 56).ordinal;
}

function equals_0(other){
  return this === (other == null?null:other);
}

function getClass_8(){
  return Ljava_lang_Enum_2_classLit;
}

function hashCode_1(){
  return this.$H || (this.$H = ++sNextHashId);
}

function toString_1(){
  return this.name_0;
}

function Enum(){
}

_ = Enum.prototype = new Object_0;
_.compareTo$ = compareTo;
_.equals$ = equals_0;
_.getClass$ = getClass_8;
_.hashCode$ = hashCode_1;
_.toString$ = toString_1;
_.typeId$ = 8;
_.name_0 = null;
_.ordinal = 0;
function $clinit_12(){
  $clinit_12 = nullMethod;
  BOX_SHAPE_PROXYTYPE = $BroadphaseNativeType(new BroadphaseNativeType, 'BOX_SHAPE_PROXYTYPE', 0);
  TRIANGLE_SHAPE_PROXYTYPE = $BroadphaseNativeType(new BroadphaseNativeType, 'TRIANGLE_SHAPE_PROXYTYPE', 1);
  TETRAHEDRAL_SHAPE_PROXYTYPE = $BroadphaseNativeType(new BroadphaseNativeType, 'TETRAHEDRAL_SHAPE_PROXYTYPE', 2);
  CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE = $BroadphaseNativeType(new BroadphaseNativeType, 'CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE', 3);
  CONVEX_HULL_SHAPE_PROXYTYPE = $BroadphaseNativeType(new BroadphaseNativeType, 'CONVEX_HULL_SHAPE_PROXYTYPE', 4);
  IMPLICIT_CONVEX_SHAPES_START_HERE = $BroadphaseNativeType(new BroadphaseNativeType, 'IMPLICIT_CONVEX_SHAPES_START_HERE', 5);
  SPHERE_SHAPE_PROXYTYPE = $BroadphaseNativeType(new BroadphaseNativeType, 'SPHERE_SHAPE_PROXYTYPE', 6);
  MULTI_SPHERE_SHAPE_PROXYTYPE = $BroadphaseNativeType(new BroadphaseNativeType, 'MULTI_SPHERE_SHAPE_PROXYTYPE', 7);
  CAPSULE_SHAPE_PROXYTYPE = $BroadphaseNativeType(new BroadphaseNativeType, 'CAPSULE_SHAPE_PROXYTYPE', 8);
  CONE_SHAPE_PROXYTYPE = $BroadphaseNativeType(new BroadphaseNativeType, 'CONE_SHAPE_PROXYTYPE', 9);
  CONVEX_SHAPE_PROXYTYPE = $BroadphaseNativeType(new BroadphaseNativeType, 'CONVEX_SHAPE_PROXYTYPE', 10);
  CYLINDER_SHAPE_PROXYTYPE = $BroadphaseNativeType(new BroadphaseNativeType, 'CYLINDER_SHAPE_PROXYTYPE', 11);
  UNIFORM_SCALING_SHAPE_PROXYTYPE = $BroadphaseNativeType(new BroadphaseNativeType, 'UNIFORM_SCALING_SHAPE_PROXYTYPE', 12);
  MINKOWSKI_SUM_SHAPE_PROXYTYPE = $BroadphaseNativeType(new BroadphaseNativeType, 'MINKOWSKI_SUM_SHAPE_PROXYTYPE', 13);
  MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE = $BroadphaseNativeType(new BroadphaseNativeType, 'MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE', 14);
  CONCAVE_SHAPES_START_HERE = $BroadphaseNativeType(new BroadphaseNativeType, 'CONCAVE_SHAPES_START_HERE', 15);
  TRIANGLE_MESH_SHAPE_PROXYTYPE = $BroadphaseNativeType(new BroadphaseNativeType, 'TRIANGLE_MESH_SHAPE_PROXYTYPE', 16);
  SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE = $BroadphaseNativeType(new BroadphaseNativeType, 'SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE', 17);
  FAST_CONCAVE_MESH_PROXYTYPE = $BroadphaseNativeType(new BroadphaseNativeType, 'FAST_CONCAVE_MESH_PROXYTYPE', 18);
  TERRAIN_SHAPE_PROXYTYPE = $BroadphaseNativeType(new BroadphaseNativeType, 'TERRAIN_SHAPE_PROXYTYPE', 19);
  GIMPACT_SHAPE_PROXYTYPE = $BroadphaseNativeType(new BroadphaseNativeType, 'GIMPACT_SHAPE_PROXYTYPE', 20);
  MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE = $BroadphaseNativeType(new BroadphaseNativeType, 'MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE', 21);
  EMPTY_SHAPE_PROXYTYPE = $BroadphaseNativeType(new BroadphaseNativeType, 'EMPTY_SHAPE_PROXYTYPE', 22);
  STATIC_PLANE_PROXYTYPE = $BroadphaseNativeType(new BroadphaseNativeType, 'STATIC_PLANE_PROXYTYPE', 23);
  CONCAVE_SHAPES_END_HERE = $BroadphaseNativeType(new BroadphaseNativeType, 'CONCAVE_SHAPES_END_HERE', 24);
  COMPOUND_SHAPE_PROXYTYPE = $BroadphaseNativeType(new BroadphaseNativeType, 'COMPOUND_SHAPE_PROXYTYPE', 25);
  SOFTBODY_SHAPE_PROXYTYPE = $BroadphaseNativeType(new BroadphaseNativeType, 'SOFTBODY_SHAPE_PROXYTYPE', 26);
  MAX_BROADPHASE_COLLISION_TYPES = $BroadphaseNativeType(new BroadphaseNativeType, 'MAX_BROADPHASE_COLLISION_TYPES', 27);
  values_0 = initValues(_3Lcom_bulletphysics_gwt_client_collision_broadphase_BroadphaseNativeType_2_classLit, 126, 45, [BOX_SHAPE_PROXYTYPE, TRIANGLE_SHAPE_PROXYTYPE, TETRAHEDRAL_SHAPE_PROXYTYPE, CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE, CONVEX_HULL_SHAPE_PROXYTYPE, IMPLICIT_CONVEX_SHAPES_START_HERE, SPHERE_SHAPE_PROXYTYPE, MULTI_SPHERE_SHAPE_PROXYTYPE, CAPSULE_SHAPE_PROXYTYPE, CONE_SHAPE_PROXYTYPE, CONVEX_SHAPE_PROXYTYPE, CYLINDER_SHAPE_PROXYTYPE, UNIFORM_SCALING_SHAPE_PROXYTYPE, MINKOWSKI_SUM_SHAPE_PROXYTYPE, MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE, CONCAVE_SHAPES_START_HERE, TRIANGLE_MESH_SHAPE_PROXYTYPE, SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE, FAST_CONCAVE_MESH_PROXYTYPE, TERRAIN_SHAPE_PROXYTYPE, GIMPACT_SHAPE_PROXYTYPE, MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE, EMPTY_SHAPE_PROXYTYPE, STATIC_PLANE_PROXYTYPE, CONCAVE_SHAPES_END_HERE, COMPOUND_SHAPE_PROXYTYPE, SOFTBODY_SHAPE_PROXYTYPE, MAX_BROADPHASE_COLLISION_TYPES]);
}

function $BroadphaseNativeType(this$static, enum$name, enum$ordinal){
  $clinit_12();
  this$static.name_0 = enum$name;
  this$static.ordinal = enum$ordinal;
  return this$static;
}

function $isConcave(this$static){
  return this$static.ordinal > CONCAVE_SHAPES_START_HERE.ordinal && this$static.ordinal < CONCAVE_SHAPES_END_HERE.ordinal;
}

function getClass_9(){
  return Lcom_bulletphysics_gwt_client_collision_broadphase_BroadphaseNativeType_2_classLit;
}

function values_1(){
  $clinit_12();
  return initValues(_3Lcom_bulletphysics_gwt_client_collision_broadphase_BroadphaseNativeType_2_classLit, 126, 45, [BOX_SHAPE_PROXYTYPE, TRIANGLE_SHAPE_PROXYTYPE, TETRAHEDRAL_SHAPE_PROXYTYPE, CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE, CONVEX_HULL_SHAPE_PROXYTYPE, IMPLICIT_CONVEX_SHAPES_START_HERE, SPHERE_SHAPE_PROXYTYPE, MULTI_SPHERE_SHAPE_PROXYTYPE, CAPSULE_SHAPE_PROXYTYPE, CONE_SHAPE_PROXYTYPE, CONVEX_SHAPE_PROXYTYPE, CYLINDER_SHAPE_PROXYTYPE, UNIFORM_SCALING_SHAPE_PROXYTYPE, MINKOWSKI_SUM_SHAPE_PROXYTYPE, MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE, CONCAVE_SHAPES_START_HERE, TRIANGLE_MESH_SHAPE_PROXYTYPE, SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE, FAST_CONCAVE_MESH_PROXYTYPE, TERRAIN_SHAPE_PROXYTYPE, GIMPACT_SHAPE_PROXYTYPE, MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE, EMPTY_SHAPE_PROXYTYPE, STATIC_PLANE_PROXYTYPE, CONCAVE_SHAPES_END_HERE, COMPOUND_SHAPE_PROXYTYPE, SOFTBODY_SHAPE_PROXYTYPE, MAX_BROADPHASE_COLLISION_TYPES]);
}

function BroadphaseNativeType(){
}

_ = BroadphaseNativeType.prototype = new Enum;
_.getClass$ = getClass_9;
_.typeId$ = 9;
var BOX_SHAPE_PROXYTYPE, CAPSULE_SHAPE_PROXYTYPE, COMPOUND_SHAPE_PROXYTYPE, CONCAVE_SHAPES_END_HERE, CONCAVE_SHAPES_START_HERE, CONE_SHAPE_PROXYTYPE, CONVEX_HULL_SHAPE_PROXYTYPE, CONVEX_SHAPE_PROXYTYPE, CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE, CYLINDER_SHAPE_PROXYTYPE, EMPTY_SHAPE_PROXYTYPE, FAST_CONCAVE_MESH_PROXYTYPE, GIMPACT_SHAPE_PROXYTYPE, IMPLICIT_CONVEX_SHAPES_START_HERE, MAX_BROADPHASE_COLLISION_TYPES, MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE, MINKOWSKI_SUM_SHAPE_PROXYTYPE, MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE, MULTI_SPHERE_SHAPE_PROXYTYPE, SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE, SOFTBODY_SHAPE_PROXYTYPE, SPHERE_SHAPE_PROXYTYPE, STATIC_PLANE_PROXYTYPE, TERRAIN_SHAPE_PROXYTYPE, TETRAHEDRAL_SHAPE_PROXYTYPE, TRIANGLE_MESH_SHAPE_PROXYTYPE, TRIANGLE_SHAPE_PROXYTYPE, UNIFORM_SCALING_SHAPE_PROXYTYPE, values_0;
function $BroadphasePair(this$static, pProxy0, pProxy1){
  this$static.pProxy0 = pProxy0;
  this$static.pProxy1 = pProxy1;
  this$static.algorithm = null;
  this$static.userInfo = null;
  return this$static;
}

function $set_0(this$static, p){
  this$static.pProxy0 = p.pProxy0;
  this$static.pProxy1 = p.pProxy1;
  this$static.algorithm = p.algorithm;
  this$static.userInfo = p.userInfo;
}

function getClass_10(){
  return Lcom_bulletphysics_gwt_client_collision_broadphase_BroadphasePair_2_classLit;
}

function BroadphasePair(){
}

_ = BroadphasePair.prototype = new Object_0;
_.getClass$ = getClass_10;
_.typeId$ = 10;
_.algorithm = null;
_.pProxy0 = null;
_.pProxy1 = null;
_.userInfo = null;
function getClass_11(){
  return Lcom_bulletphysics_gwt_client_collision_broadphase_CollisionAlgorithm_2_classLit;
}

function CollisionAlgorithm(){
}

_ = CollisionAlgorithm.prototype = new Object_0;
_.getClass$ = getClass_11;
_.typeId$ = 11;
_.createFunc = null;
_.dispatcher = null;
function getClass_12(){
  return Lcom_bulletphysics_gwt_client_collision_broadphase_CollisionAlgorithmConstructionInfo_2_classLit;
}

function CollisionAlgorithmConstructionInfo(){
}

_ = CollisionAlgorithmConstructionInfo.prototype = new Object_0;
_.getClass$ = getClass_12;
_.typeId$ = 0;
_.dispatcher1 = null;
_.manifold = null;
function $clinit_16(){
  $clinit_16 = nullMethod;
  DISPATCH_DISCRETE = $DispatchFunc(new DispatchFunc, 'DISPATCH_DISCRETE', 0);
  DISPATCH_CONTINUOUS = $DispatchFunc(new DispatchFunc, 'DISPATCH_CONTINUOUS', 1);
}

function $DispatchFunc(this$static, enum$name, enum$ordinal){
  $clinit_16();
  this$static.name_0 = enum$name;
  this$static.ordinal = enum$ordinal;
  return this$static;
}

function getClass_13(){
  return Lcom_bulletphysics_gwt_client_collision_broadphase_DispatchFunc_2_classLit;
}

function values_2(){
  $clinit_16();
  return initValues(_3Lcom_bulletphysics_gwt_client_collision_broadphase_DispatchFunc_2_classLit, 128, 46, [DISPATCH_DISCRETE, DISPATCH_CONTINUOUS]);
}

function DispatchFunc(){
}

_ = DispatchFunc.prototype = new Enum;
_.getClass$ = getClass_13;
_.typeId$ = 12;
var DISPATCH_CONTINUOUS, DISPATCH_DISCRETE;
function getClass_14(){
  return Lcom_bulletphysics_gwt_client_collision_broadphase_Dispatcher_2_classLit;
}

function Dispatcher(){
}

_ = Dispatcher.prototype = new Object_0;
_.getClass$ = getClass_14;
_.typeId$ = 0;
function $DispatcherInfo(this$static){
  this$static.dispatchFunc = ($clinit_16() , DISPATCH_DISCRETE);
  this$static.timeOfImpact = 1;
  return this$static;
}

function getClass_15(){
  return Lcom_bulletphysics_gwt_client_collision_broadphase_DispatcherInfo_2_classLit;
}

function DispatcherInfo(){
}

_ = DispatcherInfo.prototype = new Object_0;
_.getClass$ = getClass_15;
_.typeId$ = 0;
_.dispatchFunc = null;
_.timeOfImpact = 0;
function getClass_16(){
  return Lcom_bulletphysics_gwt_client_collision_broadphase_OverlappingPairCache_2_classLit;
}

function OverlappingPairCache(){
}

_ = OverlappingPairCache.prototype = new Object_0;
_.getClass$ = getClass_16;
_.typeId$ = 0;
function $HashedOverlappingPairCache(this$static){
  get_1(Lcom_bulletphysics_gwt_client_collision_broadphase_BroadphasePair_2_classLit, ($clinit_125() , broadphasePairFactory));
  this$static.overlappingPairArray = $ObjectArrayList(new ObjectArrayList);
  this$static.hashTable = $IntArrayList(new IntArrayList);
  this$static.next = $IntArrayList(new IntArrayList);
  $growTables(this$static);
  return this$static;
}

function $addOverlappingPair(this$static, proxy0, proxy1){
  $clinit_1();
  ++gAddedPairs;
  if (!(collides = (proxy0.collisionFilterGroup & proxy1.collisionFilterMask) != 0 , collides && (proxy1.collisionFilterGroup & proxy0.collisionFilterMask) != 0)) {
    return null;
  }
  return $internalAddPair(this$static, proxy0, proxy1);
}

function $cleanOverlappingPair(pair){
  if (pair.algorithm) {
    $freeCollisionAlgorithm(pair.algorithm);
    pair.algorithm = null;
  }
}

function $equalsPair(pair, proxyId1, proxyId2){
  return pair.pProxy0.uniqueId == proxyId1 && pair.pProxy1.uniqueId == proxyId2;
}

function $getHash(proxyId1, proxyId2){
  var key;
  key = proxyId1 | proxyId2 << 16;
  key += ~(key << 15);
  key ^= key >>> 10;
  key += key << 3;
  key ^= key >>> 6;
  key += ~(key << 11);
  key ^= key >>> 16;
  return key;
}

function $growTables(this$static){
  var curHashtableSize, hashValue, i, newCapacity, pair, proxyId1, proxyId2;
  newCapacity = this$static.overlappingPairArray.array.length;
  if (this$static.hashTable.size < newCapacity) {
    curHashtableSize = this$static.hashTable.size;
    resize(this$static.hashTable, newCapacity, 0);
    resize(this$static.next, newCapacity, 0);
    for (i = 0; i < newCapacity; ++i) {
      $set_4(this$static.hashTable, i, -1);
    }
    for (i = 0; i < newCapacity; ++i) {
      $set_4(this$static.next, i, -1);
    }
    for (i = 0; i < curHashtableSize; ++i) {
      pair = dynamicCast($get_0(this$static.overlappingPairArray, i), 14);
      proxyId1 = pair.pProxy0.uniqueId;
      proxyId2 = pair.pProxy1.uniqueId;
      hashValue = $getHash(proxyId1, proxyId2) & this$static.overlappingPairArray.array.length - 1;
      $set_4(this$static.next, i, $get(this$static.hashTable, hashValue));
      $set_4(this$static.hashTable, hashValue, i);
    }
  }
}

--></script>
<script><!--
function $internalAddPair(this$static, proxy0, proxy1){
  var count, hash, newCapacity, oldCapacity, pair, proxyId1, proxyId2, tmp;
  if (proxy0.uniqueId > proxy1.uniqueId) {
    tmp = proxy0;
    proxy0 = proxy1;
    proxy1 = tmp;
  }
  proxyId1 = proxy0.uniqueId;
  proxyId2 = proxy1.uniqueId;
  hash = $getHash(proxyId1, proxyId2) & this$static.overlappingPairArray.array.length - 1;
  pair = $internalFindPair(this$static, proxy0, proxy1, hash);
  if (pair) {
    return pair;
  }
  count = this$static.overlappingPairArray.size;
  oldCapacity = this$static.overlappingPairArray.array.length;
  $add_0(this$static.overlappingPairArray, null);
  newCapacity = this$static.overlappingPairArray.array.length;
  if (oldCapacity < newCapacity) {
    $growTables(this$static);
    hash = $getHash(proxyId1, proxyId2) & this$static.overlappingPairArray.array.length - 1;
  }
  pair = $BroadphasePair(new BroadphasePair, proxy0, proxy1);
  pair.algorithm = null;
  pair.userInfo = null;
  $set_5(this$static.overlappingPairArray, this$static.overlappingPairArray.size - 1, pair);
  $set_4(this$static.next, count, $get(this$static.hashTable, hash));
  $set_4(this$static.hashTable, hash, count);
  return pair;
}

function $internalFindPair(this$static, proxy0, proxy1, hash){
  var index, proxyId1, proxyId2;
  proxyId1 = proxy0.uniqueId;
  proxyId2 = proxy1.uniqueId;
  index = $get(this$static.hashTable, hash);
  while (index != -1 && !$equalsPair(dynamicCast($get_0(this$static.overlappingPairArray, index), 14), proxyId1, proxyId2)) {
    index = $get(this$static.next, index);
  }
  if (index == -1) {
    return null;
  }
  return dynamicCast($get_0(this$static.overlappingPairArray, index), 14);
}

function $processAllOverlappingPairs(this$static, callback){
  var i, pair;
  for (i = 0; i < this$static.overlappingPairArray.size;) {
    pair = dynamicCast($get_0(this$static.overlappingPairArray, i), 14);
    $handleCollision(callback.dispatcher.nearCallback, pair, callback.dispatcher, callback.dispatchInfo);
    ++i;
  }
}

function $removeOverlappingPair(this$static, proxy0, proxy1){
  var hash, index, last, lastHash, lastPairIndex, pair, pairIndex, previous, proxyId1, proxyId2, tmp, userData;
  $clinit_1();
  ++gRemovePairs;
  if (proxy0.uniqueId > proxy1.uniqueId) {
    tmp = proxy0;
    proxy0 = proxy1;
    proxy1 = tmp;
  }
  proxyId1 = proxy0.uniqueId;
  proxyId2 = proxy1.uniqueId;
  hash = $getHash(proxyId1, proxyId2) & this$static.overlappingPairArray.array.length - 1;
  pair = $internalFindPair(this$static, proxy0, proxy1, hash);
  if (!pair) {
    return null;
  }
  $cleanOverlappingPair(pair);
  userData = pair.userInfo;
  pairIndex = $indexOf(this$static.overlappingPairArray, pair);
  index = $get(this$static.hashTable, hash);
  previous = -1;
  while (index != pairIndex) {
    previous = index;
    index = $get(this$static.next, index);
  }
  previous != -1?$set_4(this$static.next, previous, $get(this$static.next, pairIndex)):$set_4(this$static.hashTable, hash, $get(this$static.next, pairIndex));
  lastPairIndex = this$static.overlappingPairArray.size - 1;
  if (lastPairIndex == pairIndex) {
    $remove_0(this$static.overlappingPairArray, this$static.overlappingPairArray.size - 1);
    return userData;
  }
  last = dynamicCast($get_0(this$static.overlappingPairArray, lastPairIndex), 14);
  lastHash = $getHash(last.pProxy0.uniqueId, last.pProxy1.uniqueId) & this$static.overlappingPairArray.array.length - 1;
  index = $get(this$static.hashTable, lastHash);
  previous = -1;
  while (index != lastPairIndex) {
    previous = index;
    index = $get(this$static.next, index);
  }
  previous != -1?$set_4(this$static.next, previous, $get(this$static.next, lastPairIndex)):$set_4(this$static.hashTable, lastHash, $get(this$static.next, lastPairIndex));
  $set_0(dynamicCast($get_0(this$static.overlappingPairArray, pairIndex), 14), dynamicCast($get_0(this$static.overlappingPairArray, lastPairIndex), 14));
  $set_4(this$static.next, pairIndex, $get(this$static.hashTable, lastHash));
  $set_4(this$static.hashTable, lastHash, pairIndex);
  $remove_0(this$static.overlappingPairArray, this$static.overlappingPairArray.size - 1);
  return userData;
}

function getClass_17(){
  return Lcom_bulletphysics_gwt_client_collision_broadphase_HashedOverlappingPairCache_2_classLit;
}

function HashedOverlappingPairCache(){
}

_ = HashedOverlappingPairCache.prototype = new OverlappingPairCache;
_.getClass$ = getClass_17;
_.typeId$ = 0;
function getClass_18(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_CollisionAlgorithmCreateFunc_2_classLit;
}

function CollisionAlgorithmCreateFunc(){
}

_ = CollisionAlgorithmCreateFunc.prototype = new Object_0;
_.getClass$ = getClass_18;
_.typeId$ = 13;
_.swapped = false;
function getClass_19(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_CollisionConfiguration_2_classLit;
}

function CollisionConfiguration(){
}

_ = CollisionConfiguration.prototype = new Object_0;
_.getClass$ = getClass_19;
_.typeId$ = 0;
function $clinit_25(){
  $clinit_25 = nullMethod;
  MAX_BROADPHASE_COLLISION_TYPES_0 = ($clinit_12() , MAX_BROADPHASE_COLLISION_TYPES).ordinal;
}

function $CollisionDispatcher(this$static, collisionConfiguration){
  var i, j;
  $clinit_25();
  this$static.manifoldsPool = get_1(Lcom_bulletphysics_gwt_client_collision_narrowphase_PersistentManifold_2_classLit, ($clinit_125() , persistentManifoldFactory));
  this$static.manifoldsPtr = $ArrayList(new ArrayList);
  this$static.doubleDispatch = initDims_0([_3_3Lcom_bulletphysics_gwt_client_collision_dispatch_CollisionAlgorithmCreateFunc_2_classLit, _3Lcom_bulletphysics_gwt_client_collision_dispatch_CollisionAlgorithmCreateFunc_2_classLit], [160, 129], [4, 15], [MAX_BROADPHASE_COLLISION_TYPES_0, MAX_BROADPHASE_COLLISION_TYPES_0], 0, 2, 0);
  this$static.tmpCI = new CollisionAlgorithmConstructionInfo;
  this$static.collisionPairCallback = new CollisionDispatcher$CollisionPairCallback;
  this$static.nearCallback = $DefaultNearCallback(new DefaultNearCallback);
  for (i = 0; i < MAX_BROADPHASE_COLLISION_TYPES_0; ++i) {
    for (j = 0; j < MAX_BROADPHASE_COLLISION_TYPES_0; ++j) {
      setCheck(this$static.doubleDispatch[i], j, $getCollisionAlgorithmCreateFunc(collisionConfiguration, ($clinit_12() , values_0[i]), values_0[j]));
    }
  }
  return this$static;
}

function $dispatchAllCollisionPairs(this$static, pairCache, dispatchInfo){
  $init(this$static.collisionPairCallback, dispatchInfo, this$static);
  $processAllOverlappingPairs(pairCache, this$static.collisionPairCallback);
}

function $findAlgorithm(this$static, body0, body1, sharedManifold){
  var algo, ci, createFunc;
  ci = this$static.tmpCI;
  ci.dispatcher1 = this$static;
  ci.manifold = sharedManifold;
  createFunc = this$static.doubleDispatch[body0.collisionShape.getShapeType().ordinal][body1.collisionShape.getShapeType().ordinal];
  algo = createFunc.createCollisionAlgorithm(ci, body0, body1);
  algo.createFunc = createFunc;
  return algo;
}

function $freeCollisionAlgorithm(algo){
  var createFunc;
  createFunc = algo.createFunc;
  algo.createFunc = null;
  createFunc.releaseCollisionAlgorithm(algo);
  algo.destroy();
}

function $getNewManifold(this$static, b0, b1){
  var body0, body1, manifold;
  body0 = b0;
  body1 = b1;
  manifold = dynamicCast($get_1(this$static.manifoldsPool), 16);
  manifold.body0 = body0;
  manifold.body1 = body1;
  manifold.cachedPoints = 0;
  manifold.index1a = 0;
  manifold.index1a = this$static.manifoldsPtr.size;
  $add_7(this$static.manifoldsPtr, manifold);
  return manifold;
}

function $needsCollision(this$static, body0, body1){
  var needsCollision;
  needsCollision = true;
  !this$static.staticWarningReported && ((body0.collisionFlags & 1) != 0 || (body0.collisionFlags & 2) != 0) && ((body1.collisionFlags & 1) != 0 || (body1.collisionFlags & 2) != 0) && (this$static.staticWarningReported = true);
  !(body0.activationState1 != 2 && body0.activationState1 != 5) && !(body1.activationState1 != 2 && body1.activationState1 != 5)?(needsCollision = false):!$checkCollideWith(body0, body1) && (needsCollision = false);
  return needsCollision;
}

function $releaseManifold(this$static, manifold){
  var findIndex;
  $clearManifold(manifold);
  findIndex = manifold.index1a;
  $clinit_313();
  swapImpl(this$static.manifoldsPtr, findIndex, this$static.manifoldsPtr.size - 1);
  dynamicCast($get_6(this$static.manifoldsPtr, findIndex), 16).index1a = findIndex;
  $remove_6(this$static.manifoldsPtr, this$static.manifoldsPtr.size - 1);
  $add_7(this$static.manifoldsPool.list, manifold);
}

function getClass_20(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_CollisionDispatcher_2_classLit;
}

function CollisionDispatcher(){
}

_ = CollisionDispatcher.prototype = new Dispatcher;
_.getClass$ = getClass_20;
_.typeId$ = 0;
_.nearCallback = null;
_.staticWarningReported = false;
var MAX_BROADPHASE_COLLISION_TYPES_0;
function $init(this$static, dispatchInfo, dispatcher){
  this$static.dispatchInfo = dispatchInfo;
  this$static.dispatcher = dispatcher;
}

function getClass_21(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_CollisionDispatcher$CollisionPairCallback_2_classLit;
}

function CollisionDispatcher$CollisionPairCallback(){
}

_ = CollisionDispatcher$CollisionPairCallback.prototype = new Object_0;
_.getClass$ = getClass_21;
_.typeId$ = 0;
_.dispatchInfo = null;
_.dispatcher = null;
function $activate(this$static, forceActivation){
  if (forceActivation || (this$static.collisionFlags & 3) == 0) {
    this$static.activationState1 != 4 && this$static.activationState1 != 5 && (this$static.activationState1 = 1);
    this$static.deactivationTime = 0;
  }
}

function $checkCollideWith(this$static, co){
  if (this$static.checkCollideWith) {
    return this$static.checkCollideWithOverride(co);
  }
  return true;
}

function $getInterpolationWorldTransform(this$static, out){
  $set_3(out, this$static.interpolationWorldTransform);
  return out;
}

function $getWorldTransform(this$static, out){
  $set_3(out, this$static.worldTransform);
  return out;
}

function checkCollideWithOverride(co){
  return true;
}

function getClass_22(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_CollisionObject_2_classLit;
}

function CollisionObject(){
}

_ = CollisionObject.prototype = new Object_0;
_.checkCollideWithOverride = checkCollideWithOverride;
_.getClass$ = getClass_22;
_.typeId$ = 14;
_.activationState1 = 0;
_.broadphaseHandle = null;
_.ccdSquareMotionThreshold = 0;
_.ccdSweptSphereRadius = 0;
_.checkCollideWith = false;
_.collisionFlags = 0;
_.collisionShape = null;
_.companionId = 0;
_.deactivationTime = 0;
_.friction = 0;
_.hitFraction = 0;
_.islandTag1 = 0;
_.restitution = 0;
function $clinit_28(){
  $clinit_28 = nullMethod;
  COLLISION_OBJECT = $CollisionObjectType(new CollisionObjectType, 'COLLISION_OBJECT', 0);
  RIGID_BODY = $CollisionObjectType(new CollisionObjectType, 'RIGID_BODY', 1);
  SOFT_BODY = $CollisionObjectType(new CollisionObjectType, 'SOFT_BODY', 2);
}

function $CollisionObjectType(this$static, enum$name, enum$ordinal){
  $clinit_28();
  this$static.name_0 = enum$name;
  this$static.ordinal = enum$ordinal;
  return this$static;
}

function getClass_23(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_CollisionObjectType_2_classLit;
}

function values_3(){
  $clinit_28();
  return initValues(_3Lcom_bulletphysics_gwt_client_collision_dispatch_CollisionObjectType_2_classLit, 130, 47, [COLLISION_OBJECT, RIGID_BODY, SOFT_BODY]);
}

function CollisionObjectType(){
}

_ = CollisionObjectType.prototype = new Enum;
_.getClass$ = getClass_23;
_.typeId$ = 15;
var COLLISION_OBJECT, RIGID_BODY, SOFT_BODY;
function $performDiscreteCollisionDetection(this$static){
  var dispatcher;
  $clinit_1();
  try {
    $updateAabbs(this$static);
    dispatcher = this$static.dispatcher1;
    try {
      !!dispatcher && $dispatchAllCollisionPairs(dispatcher, this$static.broadphasePairCache.pairCache, this$static.dispatchInfo);
    }
     finally {
    }
  }
   finally {
  }
}

function $updateAabbs(this$static){
  var bp, colObj, i, maxAabb, minAabb, tmp, tmpTrans;
  $clinit_1();
  try {
    $$init_48(new Transform);
    minAabb = $Vector3f_2(new Vector3f);
    maxAabb = $Vector3f_2(new Vector3f);
    tmp = $Vector3f_2(new Vector3f);
    tmpTrans = $Transform(new Transform);
    for (i = 0; i < this$static.collisionObjects.size; ++i) {
      colObj = dynamicCast($get_6(this$static.collisionObjects, i), 17);
      if (colObj.activationState1 != 2 && colObj.activationState1 != 5) {
        colObj.collisionShape.getAabb(($set_3(tmpTrans, colObj.worldTransform) , tmpTrans), minAabb, maxAabb);
        bp = this$static.broadphasePairCache;
        $sub(tmp, maxAabb, minAabb);
        (colObj.collisionFlags & 1) != 0 || tmp.x * tmp.x + tmp.y * tmp.y + tmp.z * tmp.z < 999999995904?$setAabb(bp, colObj.broadphaseHandle, minAabb, maxAabb):(colObj.activationState1 != 4 && colObj.activationState1 != 5 && (colObj.activationState1 = 5) , undefined);
      }
    }
  }
   finally {
  }
}

function getClass_24(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_CollisionWorld_2_classLit;
}

function CollisionWorld(){
}

_ = CollisionWorld.prototype = new Object_0;
_.getClass$ = getClass_24;
_.typeId$ = 0;
_.broadphasePairCache = null;
_.dispatcher1 = null;
function $CompoundCollisionAlgorithm(this$static){
  this$static.childCollisionAlgorithms = $ArrayList(new ArrayList);
  return this$static;
}

function $init_0(this$static, ci, body0, body1, isSwapped){
  var childShape, colObj, i, numChildren, otherObj, tmpShape;
  this$static.dispatcher = ci.dispatcher1;
  this$static.isSwapped = isSwapped;
  colObj = isSwapped?body1:body0;
  otherObj = isSwapped?body0:body1;
  throwClassCastExceptionUnlessNull(colObj.collisionShape);
  numChildren = null.nullMethod();
  for (i = 0; i < numChildren; ++i) {
    tmpShape = colObj.collisionShape;
    childShape = null.nullMethod();
    colObj.collisionShape = childShape;
    $add_7(this$static.childCollisionAlgorithms, $findAlgorithm(ci.dispatcher1, colObj, otherObj, null));
    colObj.collisionShape = tmpShape;
  }
}

function calculateTimeOfImpact(body0, body1, dispatchInfo, resultOut){
  var childShape, childTrans, colObj, frac, hitFraction, i, numChildren, orgTrans, otherObj, tmpShape, tmpTrans;
  colObj = this.isSwapped?body1:body0;
  otherObj = this.isSwapped?body0:body1;
  throwClassCastExceptionUnlessNull(colObj.collisionShape);
  tmpTrans = $Transform(new Transform);
  orgTrans = $Transform(new Transform);
  childTrans = $Transform(new Transform);
  hitFraction = 1;
  numChildren = this.childCollisionAlgorithms.size;
  for (i = 0; i < numChildren; ++i) {
    childShape = null.nullMethod();
    $set_3(orgTrans, colObj.worldTransform);
    null.nullMethod();
    $set_6(tmpTrans.basis, orgTrans.basis);
    $set_9(tmpTrans.origin, orgTrans.origin);
    $mul(tmpTrans, childTrans);
    $set_3(colObj.worldTransform, tmpTrans);
    tmpShape = colObj.collisionShape;
    colObj.collisionShape = childShape;
    frac = dynamicCast($get_6(this.childCollisionAlgorithms, i), 18).calculateTimeOfImpact(colObj, otherObj, dispatchInfo, resultOut);
    frac < hitFraction && (hitFraction = frac);
    colObj.collisionShape = tmpShape;
    $set_3(colObj.worldTransform, orgTrans);
  }
  return hitFraction;
}

function destroy(){
  var i, numChildren;
  numChildren = this.childCollisionAlgorithms.size;
  for (i = 0; i < numChildren; ++i) {
    $freeCollisionAlgorithm(dynamicCast($get_6(this.childCollisionAlgorithms, i), 18));
  }
  $clear(this.childCollisionAlgorithms);
}

function getClass_25(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_CompoundCollisionAlgorithm_2_classLit;
}

function processCollision(body0, body1, dispatchInfo, resultOut){
  var childShape, childTrans, colObj, i, newChildWorldTrans, numChildren, orgInterpolationTrans, orgTrans, otherObj, tmpShape;
  colObj = this.isSwapped?body1:body0;
  otherObj = this.isSwapped?body0:body1;
  throwClassCastExceptionUnlessNull(colObj.collisionShape);
  $$init_48(new Transform);
  orgTrans = $Transform(new Transform);
  childTrans = $Transform(new Transform);
  orgInterpolationTrans = $Transform(new Transform);
  newChildWorldTrans = $Transform(new Transform);
  numChildren = this.childCollisionAlgorithms.size;
  for (i = 0; i < numChildren; ++i) {
    childShape = null.nullMethod();
    $set_3(orgTrans, colObj.worldTransform);
    $set_3(orgInterpolationTrans, colObj.interpolationWorldTransform);
    null.nullMethod();
    $mul_0(newChildWorldTrans, orgTrans, childTrans);
    $set_3(colObj.worldTransform, newChildWorldTrans);
    $set_3(colObj.interpolationWorldTransform, newChildWorldTrans);
    tmpShape = colObj.collisionShape;
    colObj.collisionShape = childShape;
    dynamicCast($get_6(this.childCollisionAlgorithms, i), 18).processCollision(colObj, otherObj, dispatchInfo, resultOut);
    colObj.collisionShape = tmpShape;
    $set_3(colObj.worldTransform, orgTrans);
    $set_3(colObj.interpolationWorldTransform, orgInterpolationTrans);
  }
}

function CompoundCollisionAlgorithm(){
}

_ = CompoundCollisionAlgorithm.prototype = new CollisionAlgorithm;
_.calculateTimeOfImpact = calculateTimeOfImpact;
_.destroy = destroy;
_.getClass$ = getClass_25;
_.processCollision = processCollision;
_.typeId$ = 16;
_.isSwapped = false;
function $CompoundCollisionAlgorithm$CreateFunc(this$static){
  this$static.pool = get_1(Lcom_bulletphysics_gwt_client_collision_dispatch_CompoundCollisionAlgorithm_2_classLit, ($clinit_125() , compoundCollisionAlgorithmFactory));
  return this$static;
}

function createCollisionAlgorithm(ci, body0, body1){
  var algo;
  algo = dynamicCast($get_1(this.pool), 19);
  $init_0(algo, ci, body0, body1, false);
  return algo;
}

function getClass_26(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_CompoundCollisionAlgorithm$CreateFunc_2_classLit;
}

function releaseCollisionAlgorithm(algo){
  $add_7(this.pool.list, dynamicCast(algo, 19));
}

function CompoundCollisionAlgorithm$CreateFunc(){
}

_ = CompoundCollisionAlgorithm$CreateFunc.prototype = new CollisionAlgorithmCreateFunc;
_.createCollisionAlgorithm = createCollisionAlgorithm;
_.getClass$ = getClass_26;
_.releaseCollisionAlgorithm = releaseCollisionAlgorithm;
_.typeId$ = 17;
function $CompoundCollisionAlgorithm$SwappedCreateFunc(this$static){
  this$static.pool = get_1(Lcom_bulletphysics_gwt_client_collision_dispatch_CompoundCollisionAlgorithm_2_classLit, ($clinit_125() , compoundCollisionAlgorithmFactory));
  return this$static;
}

function createCollisionAlgorithm_0(ci, body0, body1){
  var algo;
  algo = dynamicCast($get_1(this.pool), 19);
  $init_0(algo, ci, body0, body1, true);
  return algo;
}

function getClass_27(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_CompoundCollisionAlgorithm$SwappedCreateFunc_2_classLit;
}

function releaseCollisionAlgorithm_0(algo){
  $add_7(this.pool.list, dynamicCast(algo, 19));
}

function CompoundCollisionAlgorithm$SwappedCreateFunc(){
}

_ = CompoundCollisionAlgorithm$SwappedCreateFunc.prototype = new CollisionAlgorithmCreateFunc;
_.createCollisionAlgorithm = createCollisionAlgorithm_0;
_.getClass$ = getClass_27;
_.releaseCollisionAlgorithm = releaseCollisionAlgorithm_0;
_.typeId$ = 18;
function calculateTimeOfImpact_0(body0, body1, dispatchInfo, resultOut){
  var ccdRadius0, concavebody, convexFromLocal, convexToLocal, convexbody, rayAabbMax, rayAabbMin, raycastCallback, squareMot0, tmp, tmpTrans, triBody, triInv;
  tmp = $Vector3f_2(new Vector3f);
  convexbody = this.isSwapped?body1:body0;
  triBody = this.isSwapped?body0:body1;
  $sub(tmp, $getInterpolationWorldTransform(convexbody, $Transform(new Transform)).origin, $getWorldTransform(convexbody, $Transform(new Transform)).origin);
  squareMot0 = tmp.x * tmp.x + tmp.y * tmp.y + tmp.z * tmp.z;
  if (squareMot0 < convexbody.ccdSquareMotionThreshold) {
    return 1;
  }
  tmpTrans = $Transform(new Transform);
  triInv = $getWorldTransform(triBody, $Transform(new Transform));
  $inverse(triInv);
  convexFromLocal = $Transform(new Transform);
  $mul_0(convexFromLocal, triInv, ($set_3(tmpTrans, convexbody.worldTransform) , tmpTrans));
  convexToLocal = $Transform(new Transform);
  $mul_0(convexToLocal, triInv, ($set_3(tmpTrans, convexbody.interpolationWorldTransform) , tmpTrans));
  if ($isConcave(triBody.collisionShape.getShapeType())) {
    rayAabbMin = $Vector3f_1(new Vector3f, convexFromLocal.origin);
    setMin(rayAabbMin, convexToLocal.origin);
    rayAabbMax = $Vector3f_1(new Vector3f, convexFromLocal.origin);
    setMax(rayAabbMax, convexToLocal.origin);
    ccdRadius0 = convexbody.ccdSweptSphereRadius;
    tmp.x = ccdRadius0;
    tmp.y = ccdRadius0;
    tmp.z = ccdRadius0;
    rayAabbMin.x -= tmp.x;
    rayAabbMin.y -= tmp.y;
    rayAabbMin.z -= tmp.z;
    rayAabbMax.x += tmp.x;
    rayAabbMax.y += tmp.y;
    rayAabbMax.z += tmp.z;
    raycastCallback = $ConvexConcaveCollisionAlgorithm$LocalTriangleSphereCastCallback(new ConvexConcaveCollisionAlgorithm$LocalTriangleSphereCastCallback, convexFromLocal, convexToLocal, 1);
    raycastCallback.hitFraction = convexbody.hitFraction;
    concavebody = triBody;
    throwClassCastExceptionUnlessNull(concavebody.collisionShape);
    if (raycastCallback.hitFraction < convexbody.hitFraction) {
      convexbody.hitFraction = raycastCallback.hitFraction;
      return raycastCallback.hitFraction;
    }
  }
  return 1;
}

function destroy_0(){
  $destroy(this.btConvexTriangleCallback);
}

function getClass_28(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_ConvexConcaveCollisionAlgorithm_2_classLit;
}

function processCollision_0(body0, body1, dispatchInfo, resultOut){
  var collisionMarginTriangle, convexBody, triBody, triOb;
  convexBody = this.isSwapped?body1:body0;
  triBody = this.isSwapped?body0:body1;
  if ($isConcave(triBody.collisionShape.getShapeType())) {
    triOb = triBody;
    throwClassCastExceptionUnlessNull(triOb.collisionShape);
    if (convexBody.collisionShape.getShapeType().ordinal < ($clinit_12() , CONCAVE_SHAPES_START_HERE).ordinal) {
      collisionMarginTriangle = null.nullMethod();
      resultOut.manifoldPtr = this.btConvexTriangleCallback.manifoldPtr;
      $setTimeStepAndCounters(this.btConvexTriangleCallback, collisionMarginTriangle);
      $setBodies(this.btConvexTriangleCallback.manifoldPtr, convexBody, triBody);
      null.nullMethod($getAabbMin(this.btConvexTriangleCallback, $Vector3f_2(new Vector3f)), $getAabbMax(this.btConvexTriangleCallback, $Vector3f_2(new Vector3f)));
      $refreshContactPoints(resultOut);
    }
  }
}

function ConvexConcaveCollisionAlgorithm(){
}

_ = ConvexConcaveCollisionAlgorithm.prototype = new CollisionAlgorithm;
_.calculateTimeOfImpact = calculateTimeOfImpact_0;
_.destroy = destroy_0;
_.getClass$ = getClass_28;
_.processCollision = processCollision_0;
_.typeId$ = 19;
_.btConvexTriangleCallback = null;
_.isSwapped = false;
function $ConvexConcaveCollisionAlgorithm$CreateFunc(this$static){
  this$static.pool = get_1(Lcom_bulletphysics_gwt_client_collision_dispatch_ConvexConcaveCollisionAlgorithm_2_classLit, ($clinit_125() , convexConcaveCollisionAlgorithmFactory));
  return this$static;
}

function createCollisionAlgorithm_1(ci, body0, body1){
  var algo;
  algo = dynamicCast($get_1(this.pool), 20);
  algo.dispatcher = ci.dispatcher1;
  algo.isSwapped = false;
  algo.btConvexTriangleCallback = $ConvexTriangleCallback(new ConvexTriangleCallback, algo.dispatcher, body0, body1, false);
  return algo;
}

function getClass_29(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_ConvexConcaveCollisionAlgorithm$CreateFunc_2_classLit;
}

function releaseCollisionAlgorithm_1(algo){
  $add_7(this.pool.list, dynamicCast(algo, 20));
}

function ConvexConcaveCollisionAlgorithm$CreateFunc(){
}

_ = ConvexConcaveCollisionAlgorithm$CreateFunc.prototype = new CollisionAlgorithmCreateFunc;
_.createCollisionAlgorithm = createCollisionAlgorithm_1;
_.getClass$ = getClass_29;
_.releaseCollisionAlgorithm = releaseCollisionAlgorithm_1;
_.typeId$ = 20;
function $ConvexConcaveCollisionAlgorithm$LocalTriangleSphereCastCallback(this$static, from, to, hitFraction){
  this$static.ccdSphereFromTrans = $Transform(new Transform);
  this$static.ccdSphereToTrans = $Transform(new Transform);
  $$init_48(new Transform);
  this$static.ident = $Transform(new Transform);
  $set_3(this$static.ccdSphereFromTrans, from);
  $set_3(this$static.ccdSphereToTrans, to);
  this$static.hitFraction = hitFraction;
  $setIdentity(this$static.ident);
  return this$static;
}

function getClass_30(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_ConvexConcaveCollisionAlgorithm$LocalTriangleSphereCastCallback_2_classLit;
}

function ConvexConcaveCollisionAlgorithm$LocalTriangleSphereCastCallback(){
}

_ = ConvexConcaveCollisionAlgorithm$LocalTriangleSphereCastCallback.prototype = new Object_0;
_.getClass$ = getClass_30;
_.typeId$ = 0;
_.hitFraction = 0;
function $ConvexConcaveCollisionAlgorithm$SwappedCreateFunc(this$static){
  this$static.pool = get_1(Lcom_bulletphysics_gwt_client_collision_dispatch_ConvexConcaveCollisionAlgorithm_2_classLit, ($clinit_125() , convexConcaveCollisionAlgorithmFactory));
  return this$static;
}

function createCollisionAlgorithm_2(ci, body0, body1){
  var algo;
  algo = dynamicCast($get_1(this.pool), 20);
  algo.dispatcher = ci.dispatcher1;
  algo.isSwapped = true;
  algo.btConvexTriangleCallback = $ConvexTriangleCallback(new ConvexTriangleCallback, algo.dispatcher, body0, body1, true);
  return algo;
}

function getClass_31(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_ConvexConcaveCollisionAlgorithm$SwappedCreateFunc_2_classLit;
}

function releaseCollisionAlgorithm_2(algo){
  $add_7(this.pool.list, dynamicCast(algo, 20));
}

function ConvexConcaveCollisionAlgorithm$SwappedCreateFunc(){
}

_ = ConvexConcaveCollisionAlgorithm$SwappedCreateFunc.prototype = new CollisionAlgorithmCreateFunc;
_.createCollisionAlgorithm = createCollisionAlgorithm_2;
_.getClass$ = getClass_31;
_.releaseCollisionAlgorithm = releaseCollisionAlgorithm_2;
_.typeId$ = 21;
function $ConvexConvexAlgorithm(this$static){
  this$static.pointInputsPool = get_1(Lcom_bulletphysics_gwt_client_collision_narrowphase_DiscreteCollisionDetectorInterface$ClosestPointInput_2_classLit, ($clinit_125() , closestPointInputFactory));
  this$static.gjkPairDetector = $GjkPairDetector(new GjkPairDetector);
  return this$static;
}

function $init_2(this$static, mf, ci, simplexSolver, pdSolver){
  this$static.dispatcher = ci.dispatcher1;
  $init_7(this$static.gjkPairDetector, null, null, simplexSolver, pdSolver);
  this$static.manifoldPtr = mf;
  this$static.ownManifold = false;
}

function calculateTimeOfImpact_1(col0, col1, dispatchInfo, resultOut){
  var ccd1, convex0, convex1, result, resultFraction, sphere0, sphere1, squareMot0, squareMot1, tmp, tmpTrans1, tmpTrans2, tmpTrans3, tmpTrans4, voronoiSimplex;
  tmp = $Vector3f_2(new Vector3f);
  tmpTrans1 = $Transform(new Transform);
  tmpTrans2 = $Transform(new Transform);
  resultFraction = 1;
  $sub(tmp, ($set_3(tmpTrans1, col0.interpolationWorldTransform) , tmpTrans1).origin, ($set_3(tmpTrans2, col0.worldTransform) , tmpTrans2).origin);
  squareMot0 = tmp.x * tmp.x + tmp.y * tmp.y + tmp.z * tmp.z;
  $sub(tmp, ($set_3(tmpTrans1, col1.interpolationWorldTransform) , tmpTrans1).origin, ($set_3(tmpTrans2, col1.worldTransform) , tmpTrans2).origin);
  squareMot1 = tmp.x * tmp.x + tmp.y * tmp.y + tmp.z * tmp.z;
  if (squareMot0 < col0.ccdSquareMotionThreshold && squareMot1 < col1.ccdSquareMotionThreshold) {
    return resultFraction;
  }
  tmpTrans3 = $Transform(new Transform);
  tmpTrans4 = $Transform(new Transform);
  convex0 = dynamicCast(col0.collisionShape, 21);
  sphere1 = $SphereShape(new SphereShape, col1.ccdSweptSphereRadius);
  result = $ConvexCast$CastResult(new ConvexCast$CastResult);
  voronoiSimplex = $VoronoiSimplexSolver(new VoronoiSimplexSolver);
  ccd1 = $GjkConvexCast(new GjkConvexCast, convex0, sphere1, voronoiSimplex);
  if ($calcTimeOfImpact(ccd1, ($set_3(tmpTrans1, col0.worldTransform) , tmpTrans1), ($set_3(tmpTrans2, col0.interpolationWorldTransform) , tmpTrans2), ($set_3(tmpTrans3, col1.worldTransform) , tmpTrans3), ($set_3(tmpTrans4, col1.interpolationWorldTransform) , tmpTrans4), result)) {
    col0.hitFraction > result.fraction && (col0.hitFraction = result.fraction , undefined);
    col1.hitFraction > result.fraction && (col1.hitFraction = result.fraction , undefined);
    resultFraction > result.fraction && (resultFraction = result.fraction);
  }
  convex1 = dynamicCast(col1.collisionShape, 21);
  sphere0 = $SphereShape(new SphereShape, col0.ccdSweptSphereRadius);
  result = $ConvexCast$CastResult(new ConvexCast$CastResult);
  voronoiSimplex = $VoronoiSimplexSolver(new VoronoiSimplexSolver);
  ccd1 = $GjkConvexCast(new GjkConvexCast, sphere0, convex1, voronoiSimplex);
  if ($calcTimeOfImpact(ccd1, ($set_3(tmpTrans1, col0.worldTransform) , tmpTrans1), ($set_3(tmpTrans2, col0.interpolationWorldTransform) , tmpTrans2), ($set_3(tmpTrans3, col1.worldTransform) , tmpTrans3), ($set_3(tmpTrans4, col1.interpolationWorldTransform) , tmpTrans4), result)) {
    col0.hitFraction > result.fraction && (col0.hitFraction = result.fraction , undefined);
    col1.hitFraction > result.fraction && (col1.hitFraction = result.fraction , undefined);
    resultFraction > result.fraction && (resultFraction = result.fraction);
  }
  return resultFraction;
}

function destroy_1(){
  if (this.ownManifold) {
    !!this.manifoldPtr && $releaseManifold(this.dispatcher, this.manifoldPtr);
    this.manifoldPtr = null;
  }
}

function getClass_32(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_ConvexConvexAlgorithm_2_classLit;
}

--></script>
<script><!--
function processCollision_1(body0, body1, dispatchInfo, resultOut){
  var input, min0, min1;
  if (!this.manifoldPtr) {
    this.manifoldPtr = $getNewManifold(this.dispatcher, body0, body1);
    this.ownManifold = true;
  }
  resultOut.manifoldPtr = this.manifoldPtr;
  min0 = dynamicCast(body0.collisionShape, 21);
  min1 = dynamicCast(body1.collisionShape, 21);
  input = dynamicCast($get_1(this.pointInputsPool), 22);
  input.maximumDistanceSquared = 3.4028234663852886E38;
  this.gjkPairDetector.minkowskiA = min0;
  this.gjkPairDetector.minkowskiB = min1;
  input.maximumDistanceSquared = min0.getMargin() + min1.getMargin() + 0.019999999552965164;
  input.maximumDistanceSquared *= input.maximumDistanceSquared;
  $getWorldTransform(body0, input.transformA);
  $getWorldTransform(body1, input.transformB);
  $getClosestPoints(this.gjkPairDetector, input, resultOut);
  $add_7(this.pointInputsPool.list, input);
  this.ownManifold && $refreshContactPoints(resultOut);
}

function ConvexConvexAlgorithm(){
}

_ = ConvexConvexAlgorithm.prototype = new CollisionAlgorithm;
_.calculateTimeOfImpact = calculateTimeOfImpact_1;
_.destroy = destroy_1;
_.getClass$ = getClass_32;
_.processCollision = processCollision_1;
_.typeId$ = 22;
_.manifoldPtr = null;
_.ownManifold = false;
function $ConvexConvexAlgorithm$CreateFunc(this$static, simplexSolver, pdSolver){
  this$static.pool = get_1(Lcom_bulletphysics_gwt_client_collision_dispatch_ConvexConvexAlgorithm_2_classLit, ($clinit_125() , convexConvexAlgorithmFactory));
  this$static.simplexSolver = simplexSolver;
  this$static.pdSolver = pdSolver;
  return this$static;
}

function createCollisionAlgorithm_3(ci, body0, body1){
  var algo;
  algo = dynamicCast($get_1(this.pool), 23);
  $init_2(algo, ci.manifold, ci, this.simplexSolver, this.pdSolver);
  return algo;
}

function getClass_33(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_ConvexConvexAlgorithm$CreateFunc_2_classLit;
}

function releaseCollisionAlgorithm_3(algo){
  $add_7(this.pool.list, dynamicCast(algo, 23));
}

function ConvexConvexAlgorithm$CreateFunc(){
}

_ = ConvexConvexAlgorithm$CreateFunc.prototype = new CollisionAlgorithmCreateFunc;
_.createCollisionAlgorithm = createCollisionAlgorithm_3;
_.getClass$ = getClass_33;
_.releaseCollisionAlgorithm = releaseCollisionAlgorithm_3;
_.typeId$ = 23;
_.pdSolver = null;
_.simplexSolver = null;
function $init_3(this$static, mf, ci, col0, col1, isSwapped){
  var convexObj, planeObj;
  this$static.dispatcher = ci.dispatcher1;
  this$static.ownManifold = false;
  this$static.manifoldPtr = mf;
  this$static.isSwapped = isSwapped;
  convexObj = isSwapped?col1:col0;
  planeObj = isSwapped?col0:col1;
  if (!this$static.manifoldPtr && $needsCollision(this$static.dispatcher, convexObj, planeObj)) {
    this$static.manifoldPtr = $getNewManifold(this$static.dispatcher, convexObj, planeObj);
    this$static.ownManifold = true;
  }
}

function calculateTimeOfImpact_2(body0, body1, dispatchInfo, resultOut){
  return 1;
}

function destroy_2(){
  if (this.ownManifold) {
    !!this.manifoldPtr && $releaseManifold(this.dispatcher, this.manifoldPtr);
    this.manifoldPtr = null;
  }
}

function getClass_34(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_ConvexPlaneCollisionAlgorithm_2_classLit;
}

function processCollision_2(body0, body1, dispatchInfo, resultOut){
  var convexInPlaneTrans, convexObj, convexShape, distance, hasCollision, normalOnSurfaceB, pOnB, planeConstant, planeInConvex, planeNormal, planeObj, tmp, tmpTrans, vtx, vtxInPlane, vtxInPlaneProjected, vtxInPlaneWorld;
  if (!this.manifoldPtr) {
    return;
  }
  tmpTrans = $Transform(new Transform);
  convexObj = this.isSwapped?body1:body0;
  planeObj = this.isSwapped?body0:body1;
  convexShape = dynamicCast(convexObj.collisionShape, 21);
  throwClassCastExceptionUnlessNull(planeObj.collisionShape);
  hasCollision = false;
  planeNormal = null.nullMethod($Vector3f_2(new Vector3f));
  planeConstant = null.nullMethod();
  planeInConvex = $Transform(new Transform);
  $set_3(planeInConvex, convexObj.worldTransform);
  $inverse(planeInConvex);
  $mul(planeInConvex, ($set_3(tmpTrans, planeObj.worldTransform) , tmpTrans));
  convexInPlaneTrans = $Transform(new Transform);
  $inverse_0(convexInPlaneTrans, ($set_3(tmpTrans, planeObj.worldTransform) , tmpTrans));
  $mul(convexInPlaneTrans, ($set_3(tmpTrans, convexObj.worldTransform) , tmpTrans));
  tmp = $Vector3f_2(new Vector3f);
  $negate(tmp, planeNormal);
  $transform_0(planeInConvex.basis, tmp);
  vtx = convexShape.localGetSupportingVertex(tmp, $Vector3f_2(new Vector3f));
  vtxInPlane = $Vector3f_1(new Vector3f, vtx);
  $transform_0(convexInPlaneTrans.basis, vtxInPlane);
  $add_2(vtxInPlane, convexInPlaneTrans.origin);
  distance = null.nullMethod() - planeConstant;
  vtxInPlaneProjected = $Vector3f_2(new Vector3f);
  tmp.x = distance * planeNormal.x;
  tmp.y = distance * planeNormal.y;
  tmp.z = distance * planeNormal.z;
  $sub(vtxInPlaneProjected, vtxInPlane, tmp);
  vtxInPlaneWorld = $Vector3f_1(new Vector3f, vtxInPlaneProjected);
  $transform(($set_3(tmpTrans, planeObj.worldTransform) , tmpTrans), vtxInPlaneWorld);
  hasCollision = distance < 0.019999999552965164;
  resultOut.manifoldPtr = this.manifoldPtr;
  if (hasCollision) {
    normalOnSurfaceB = $Vector3f_1(new Vector3f, planeNormal);
    $transform_0(($set_3(tmpTrans, planeObj.worldTransform) , tmpTrans).basis, normalOnSurfaceB);
    pOnB = $Vector3f_1(new Vector3f, vtxInPlaneWorld);
    $addContactPoint(resultOut, normalOnSurfaceB, pOnB, distance);
  }
  this.ownManifold && this.manifoldPtr.cachedPoints != 0 && $refreshContactPoints(resultOut);
}

function ConvexPlaneCollisionAlgorithm(){
}

_ = ConvexPlaneCollisionAlgorithm.prototype = new CollisionAlgorithm;
_.calculateTimeOfImpact = calculateTimeOfImpact_2;
_.destroy = destroy_2;
_.getClass$ = getClass_34;
_.processCollision = processCollision_2;
_.typeId$ = 24;
_.isSwapped = false;
_.manifoldPtr = null;
_.ownManifold = false;
function $ConvexPlaneCollisionAlgorithm$CreateFunc(this$static){
  this$static.pool = get_1(Lcom_bulletphysics_gwt_client_collision_dispatch_ConvexPlaneCollisionAlgorithm_2_classLit, ($clinit_125() , convexPlaneCollisionAlgorithmFactory));
  return this$static;
}

function createCollisionAlgorithm_4(ci, body0, body1){
  var algo;
  algo = dynamicCast($get_1(this.pool), 24);
  this.swapped?$init_3(algo, null, ci, body0, body1, true):$init_3(algo, null, ci, body0, body1, false);
  return algo;
}

function getClass_35(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_ConvexPlaneCollisionAlgorithm$CreateFunc_2_classLit;
}

function releaseCollisionAlgorithm_4(algo){
  $add_7(this.pool.list, dynamicCast(algo, 24));
}

function ConvexPlaneCollisionAlgorithm$CreateFunc(){
}

_ = ConvexPlaneCollisionAlgorithm$CreateFunc.prototype = new CollisionAlgorithmCreateFunc;
_.createCollisionAlgorithm = createCollisionAlgorithm_4;
_.getClass$ = getClass_35;
_.releaseCollisionAlgorithm = releaseCollisionAlgorithm_4;
_.typeId$ = 25;
function $ConvexTriangleCallback(this$static, dispatcher, body0, body1, isSwapped){
  this$static.aabbMin = $Vector3f_2(new Vector3f);
  this$static.aabbMax = $Vector3f_2(new Vector3f);
  $TriangleShape(new TriangleShape);
  this$static.dispatcher = dispatcher;
  this$static.convexBody = isSwapped?body1:body0;
  this$static.triBody = isSwapped?body0:body1;
  this$static.manifoldPtr = $getNewManifold(dispatcher, this$static.convexBody, this$static.triBody);
  $clearManifold(this$static.manifoldPtr);
  return this$static;
}

function $destroy(this$static){
  $clearManifold(this$static.manifoldPtr);
  $releaseManifold(this$static.dispatcher, this$static.manifoldPtr);
}

function $getAabbMax(this$static, out){
  $set_9(out, this$static.aabbMax);
  return out;
}

function $getAabbMin(this$static, out){
  $set_9(out, this$static.aabbMin);
  return out;
}

function $setTimeStepAndCounters(this$static, collisionMarginTriangle){
  var convexInTriangleSpace, convexShape, extra, extraMargin;
  convexInTriangleSpace = $Transform(new Transform);
  $getWorldTransform(this$static.triBody, convexInTriangleSpace);
  $inverse(convexInTriangleSpace);
  $mul(convexInTriangleSpace, $getWorldTransform(this$static.convexBody, $Transform(new Transform)));
  convexShape = this$static.convexBody.collisionShape;
  convexShape.getAabb(convexInTriangleSpace, this$static.aabbMin, this$static.aabbMax);
  extraMargin = collisionMarginTriangle;
  extra = $Vector3f_2(new Vector3f);
  extra.x = extraMargin;
  extra.y = extraMargin;
  extra.z = extraMargin;
  $add_2(this$static.aabbMax, extra);
  $sub_0(this$static.aabbMin, extra);
}

function getClass_36(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_ConvexTriangleCallback_2_classLit;
}

function ConvexTriangleCallback(){
}

_ = ConvexTriangleCallback.prototype = new Object_0;
_.getClass$ = getClass_36;
_.typeId$ = 0;
_.convexBody = null;
_.dispatcher = null;
_.manifoldPtr = null;
_.triBody = null;
function $DefaultCollisionConfiguration(this$static){
  this$static.simplexSolver = $VoronoiSimplexSolver(new VoronoiSimplexSolver);
  this$static.pdSolver = $GjkEpaPenetrationDepthSolver(new GjkEpaPenetrationDepthSolver);
  this$static.convexConvexCreateFunc = $ConvexConvexAlgorithm$CreateFunc(new ConvexConvexAlgorithm$CreateFunc, this$static.simplexSolver, this$static.pdSolver);
  this$static.convexConcaveCreateFunc = $ConvexConcaveCollisionAlgorithm$CreateFunc(new ConvexConcaveCollisionAlgorithm$CreateFunc);
  this$static.swappedConvexConcaveCreateFunc = $ConvexConcaveCollisionAlgorithm$SwappedCreateFunc(new ConvexConcaveCollisionAlgorithm$SwappedCreateFunc);
  this$static.compoundCreateFunc = $CompoundCollisionAlgorithm$CreateFunc(new CompoundCollisionAlgorithm$CreateFunc);
  this$static.swappedCompoundCreateFunc = $CompoundCollisionAlgorithm$SwappedCreateFunc(new CompoundCollisionAlgorithm$SwappedCreateFunc);
  this$static.emptyCreateFunc = new EmptyAlgorithm$CreateFunc;
  this$static.sphereSphereCF = $SphereSphereCollisionAlgorithm$CreateFunc(new SphereSphereCollisionAlgorithm$CreateFunc);
  this$static.convexPlaneCF = $ConvexPlaneCollisionAlgorithm$CreateFunc(new ConvexPlaneCollisionAlgorithm$CreateFunc);
  this$static.planeConvexCF = $ConvexPlaneCollisionAlgorithm$CreateFunc(new ConvexPlaneCollisionAlgorithm$CreateFunc);
  this$static.planeConvexCF.swapped = true;
  return this$static;
}

function $getCollisionAlgorithmCreateFunc(this$static, proxyType0, proxyType1){
  if (proxyType0 == ($clinit_12() , SPHERE_SHAPE_PROXYTYPE) && proxyType1 == SPHERE_SHAPE_PROXYTYPE) {
    return this$static.sphereSphereCF;
  }
  if (proxyType0.ordinal < CONCAVE_SHAPES_START_HERE.ordinal && proxyType1 == STATIC_PLANE_PROXYTYPE) {
    return this$static.convexPlaneCF;
  }
  if (proxyType1.ordinal < CONCAVE_SHAPES_START_HERE.ordinal && proxyType0 == STATIC_PLANE_PROXYTYPE) {
    return this$static.planeConvexCF;
  }
  if (proxyType0.ordinal < CONCAVE_SHAPES_START_HERE.ordinal && proxyType1.ordinal < CONCAVE_SHAPES_START_HERE.ordinal) {
    return this$static.convexConvexCreateFunc;
  }
  if (proxyType0.ordinal < CONCAVE_SHAPES_START_HERE.ordinal && proxyType1.ordinal > CONCAVE_SHAPES_START_HERE.ordinal && proxyType1.ordinal < CONCAVE_SHAPES_END_HERE.ordinal) {
    return this$static.convexConcaveCreateFunc;
  }
  if (proxyType1.ordinal < CONCAVE_SHAPES_START_HERE.ordinal && proxyType0.ordinal > CONCAVE_SHAPES_START_HERE.ordinal && proxyType0.ordinal < CONCAVE_SHAPES_END_HERE.ordinal) {
    return this$static.swappedConvexConcaveCreateFunc;
  }
  if (proxyType0.ordinal == COMPOUND_SHAPE_PROXYTYPE.ordinal) {
    return this$static.compoundCreateFunc;
  }
   else {
    if (proxyType1.ordinal == COMPOUND_SHAPE_PROXYTYPE.ordinal) {
      return this$static.swappedCompoundCreateFunc;
    }
  }
  return this$static.emptyCreateFunc;
}

function getClass_37(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_DefaultCollisionConfiguration_2_classLit;
}

function DefaultCollisionConfiguration(){
}

_ = DefaultCollisionConfiguration.prototype = new CollisionConfiguration;
_.getClass$ = getClass_37;
_.typeId$ = 0;
_.compoundCreateFunc = null;
_.convexConcaveCreateFunc = null;
_.convexConvexCreateFunc = null;
_.convexPlaneCF = null;
_.emptyCreateFunc = null;
_.pdSolver = null;
_.planeConvexCF = null;
_.simplexSolver = null;
_.sphereSphereCF = null;
_.swappedCompoundCreateFunc = null;
_.swappedConvexConcaveCreateFunc = null;
function $DefaultNearCallback(this$static){
  this$static.contactPointResult = $ManifoldResult(new ManifoldResult);
  return this$static;
}

function $handleCollision(this$static, collisionPair, dispatcher, dispatchInfo){
  var colObj0, colObj1, toi;
  colObj0 = collisionPair.pProxy0.clientObject;
  colObj1 = collisionPair.pProxy1.clientObject;
  if ($needsCollision(dispatcher, colObj0, colObj1)) {
    !collisionPair.algorithm && (collisionPair.algorithm = $findAlgorithm(dispatcher, colObj0, colObj1, null));
    if (collisionPair.algorithm) {
      $init_4(this$static.contactPointResult, colObj0, colObj1);
      if (dispatchInfo.dispatchFunc == ($clinit_16() , DISPATCH_DISCRETE)) {
        collisionPair.algorithm.processCollision(colObj0, colObj1, dispatchInfo, this$static.contactPointResult);
      }
       else {
        toi = collisionPair.algorithm.calculateTimeOfImpact(colObj0, colObj1, dispatchInfo, this$static.contactPointResult);
        dispatchInfo.timeOfImpact > toi && (dispatchInfo.timeOfImpact = toi);
      }
    }
  }
}

function getClass_38(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_DefaultNearCallback_2_classLit;
}

function DefaultNearCallback(){
}

_ = DefaultNearCallback.prototype = new Object_0;
_.getClass$ = getClass_38;
_.typeId$ = 0;
function $clinit_44(){
  $clinit_44 = nullMethod;
  INSTANCE = ($clinit_44() , new EmptyAlgorithm);
}

function calculateTimeOfImpact_3(body0, body1, dispatchInfo, resultOut){
  return 1;
}

function destroy_3(){
}

function getClass_39(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_EmptyAlgorithm_2_classLit;
}

function processCollision_3(body0, body1, dispatchInfo, resultOut){
}

function EmptyAlgorithm(){
}

_ = EmptyAlgorithm.prototype = new CollisionAlgorithm;
_.calculateTimeOfImpact = calculateTimeOfImpact_3;
_.destroy = destroy_3;
_.getClass$ = getClass_39;
_.processCollision = processCollision_3;
_.typeId$ = 26;
var INSTANCE;
function createCollisionAlgorithm_5(ci, body0, body1){
  return $clinit_44() , INSTANCE;
}

function getClass_40(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_EmptyAlgorithm$CreateFunc_2_classLit;
}

function releaseCollisionAlgorithm_5(algo){
}

function EmptyAlgorithm$CreateFunc(){
}

_ = EmptyAlgorithm$CreateFunc.prototype = new CollisionAlgorithmCreateFunc;
_.createCollisionAlgorithm = createCollisionAlgorithm_5;
_.getClass$ = getClass_40;
_.releaseCollisionAlgorithm = releaseCollisionAlgorithm_5;
_.typeId$ = 27;
function $ManifoldResult(this$static){
  this$static.pointsPool = get_1(Lcom_bulletphysics_gwt_client_collision_narrowphase_ManifoldPoint_2_classLit, ($clinit_125() , manifoldPointFactory));
  this$static.rootTransA = $Transform(new Transform);
  this$static.rootTransB = $Transform(new Transform);
  return this$static;
}

function $addContactPoint(this$static, normalOnBInWorld, pointInWorld, depth){
  var insertIndex, isSwapped, localA, localB, newPt, pointA, friction;
  if (depth > 0.019999999552965164) {
    return;
  }
  isSwapped = this$static.manifoldPtr.body0 != this$static.body0;
  pointA = $Vector3f_2(new Vector3f);
  $scaleAdd(pointA, depth, normalOnBInWorld, pointInWorld);
  localA = $Vector3f_2(new Vector3f);
  localB = $Vector3f_2(new Vector3f);
  if (isSwapped) {
    $invXform(this$static.rootTransB, pointA, localA);
    $invXform(this$static.rootTransA, pointInWorld, localB);
  }
   else {
    $invXform(this$static.rootTransA, pointA, localA);
    $invXform(this$static.rootTransB, pointInWorld, localB);
  }
  newPt = dynamicCast($get_1(this$static.pointsPool), 25);
  $set_9(newPt.localPointA, localA);
  $set_9(newPt.localPointB, localB);
  $set_9(newPt.normalWorldOnB, normalOnBInWorld);
  newPt.distance1 = depth;
  newPt.combinedFriction = 0;
  newPt.combinedRestitution = 0;
  newPt.userPersistentData = null;
  newPt.appliedImpulse = 0;
  newPt.lateralFrictionInitialized = false;
  newPt.appliedImpulseLateral1 = 0;
  newPt.appliedImpulseLateral2 = 0;
  newPt.lifeTime = 0;
  $set_9(newPt.positionWorldOnA, pointA);
  $set_9(newPt.positionWorldOnB, pointInWorld);
  insertIndex = $getCacheEntry(this$static.manifoldPtr, newPt);
  newPt.combinedFriction = (friction = this$static.body0.friction * this$static.body1.friction , friction < -10 && (friction = -10) , friction > 10 && (friction = 10) , friction);
  newPt.combinedRestitution = this$static.body0.restitution * this$static.body1.restitution;
  newPt.partId0 = this$static.partId0;
  newPt.partId1 = this$static.partId1;
  newPt.index0 = this$static.index0;
  newPt.index1 = this$static.index1;
  insertIndex >= 0?$replaceContactPoint(this$static.manifoldPtr, newPt, insertIndex):(insertIndex = $addManifoldPoint(this$static.manifoldPtr, newPt));
  $add_7(this$static.pointsPool.list, newPt);
}

function $init_4(this$static, body0, body1){
  this$static.body0 = body0;
  this$static.body1 = body1;
  $getWorldTransform(body0, this$static.rootTransA);
  $getWorldTransform(body1, this$static.rootTransB);
}

function $refreshContactPoints(this$static){
  var isSwapped;
  if (this$static.manifoldPtr.cachedPoints == 0) {
    return;
  }
  isSwapped = this$static.manifoldPtr.body0 != this$static.body0;
  isSwapped?$refreshContactPoints_0(this$static.manifoldPtr, this$static.rootTransB, this$static.rootTransA):$refreshContactPoints_0(this$static.manifoldPtr, this$static.rootTransA, this$static.rootTransB);
}

function addContactPoint(normalOnBInWorld, pointInWorld, depth){
  $addContactPoint(this, normalOnBInWorld, pointInWorld, depth);
}

function getClass_41(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_ManifoldResult_2_classLit;
}

function ManifoldResult(){
}

_ = ManifoldResult.prototype = new Object_0;
_.addContactPoint = addContactPoint;
_.getClass$ = getClass_41;
_.typeId$ = 0;
_.body0 = null;
_.body1 = null;
_.index0 = 0;
_.index1 = 0;
_.manifoldPtr = null;
_.partId0 = 0;
_.partId1 = 0;
function $clinit_48(){
  $clinit_48 = nullMethod;
  persistentManifoldComparator = new SimulationIslandManager$1;
}

function $SimulationIslandManager(this$static){
  $clinit_48();
  this$static.unionFind = $UnionFind(new UnionFind);
  this$static.islandmanifold = $ArrayList(new ArrayList);
  this$static.islandBodies = $ArrayList(new ArrayList);
  return this$static;
}

function $buildAndProcessIslands(this$static, dispatcher, collisionObjects, callback){
  var allSleeping, colObj0, colObj1, curIslandId, endIslandIndex, endManifoldIndex, i, idx, islandId, islandSleeping, manifold, maxNumManifolds, numElem, numIslandManifolds, numManifolds, startIslandIndex, startManifoldIndex, startManifold_idx;
  $clinit_1();
  try {
    $sortIslands(this$static.unionFind);
    numElem = this$static.unionFind.elements.size;
    endIslandIndex = 1;
    for (startIslandIndex = 0; startIslandIndex < numElem; startIslandIndex = endIslandIndex) {
      islandId = dynamicCast($get_6(this$static.unionFind.elements, startIslandIndex), 28).id;
      for (endIslandIndex = startIslandIndex + 1; endIslandIndex < numElem && dynamicCast($get_6(this$static.unionFind.elements, endIslandIndex), 28).id == islandId; ++endIslandIndex) {
      }
      allSleeping = true;
      for (idx = startIslandIndex; idx < endIslandIndex; ++idx) {
        i = dynamicCast($get_6(this$static.unionFind.elements, idx), 28).sz;
        colObj0 = dynamicCast((checkIndex(i, collisionObjects.size) , collisionObjects.array[i]), 17);
        if (colObj0.islandTag1 == islandId) {
          colObj0.activationState1 == 1 && (allSleeping = false);
          colObj0.activationState1 == 4 && (allSleeping = false);
        }
      }
      if (allSleeping) {
        for (idx = startIslandIndex; idx < endIslandIndex; ++idx) {
          i = dynamicCast($get_6(this$static.unionFind.elements, idx), 28).sz;
          colObj0 = dynamicCast((checkIndex(i, collisionObjects.size) , collisionObjects.array[i]), 17);
          colObj0.islandTag1 == islandId && (colObj0.activationState1 != 4 && colObj0.activationState1 != 5 && (colObj0.activationState1 = 2) , undefined);
        }
      }
       else {
        for (idx = startIslandIndex; idx < endIslandIndex; ++idx) {
          i = dynamicCast($get_6(this$static.unionFind.elements, idx), 28).sz;
          colObj0 = dynamicCast((checkIndex(i, collisionObjects.size) , collisionObjects.array[i]), 17);
          colObj0.islandTag1 == islandId && colObj0.activationState1 == 2 && (colObj0.activationState1 != 4 && colObj0.activationState1 != 5 && (colObj0.activationState1 = 3) , undefined);
        }
      }
    }
    maxNumManifolds = dispatcher.manifoldsPtr.size;
    for (i = 0; i < maxNumManifolds; ++i) {
      manifold = dynamicCast($get_6(dispatcher.manifoldsPtr, i), 16);
      colObj0 = manifold.body0;
      colObj1 = manifold.body1;
      if (!!colObj0 && colObj0.activationState1 != 2 || !!colObj1 && colObj1.activationState1 != 2) {
        (colObj0.collisionFlags & 2) != 0 && colObj0.activationState1 != 2 && $activate(colObj1, false);
        (colObj1.collisionFlags & 2) != 0 && colObj1.activationState1 != 2 && $activate(colObj0, false);
        (hasResponse = (colObj0.collisionFlags & 4) == 0 && (colObj1.collisionFlags & 4) == 0 , hasResponse && ((colObj0.collisionFlags & 3) == 0 || (colObj1.collisionFlags & 3) == 0)) && $add_7(this$static.islandmanifold, manifold);
      }
    }
    numManifolds = this$static.islandmanifold.size;
    quickSort(this$static.islandmanifold, persistentManifoldComparator);
    startManifoldIndex = 0;
    endManifoldIndex = 1;
    for (startIslandIndex = 0; startIslandIndex < numElem; startIslandIndex = endIslandIndex) {
      islandId = dynamicCast($get_6(this$static.unionFind.elements, startIslandIndex), 28).id;
      islandSleeping = false;
      for (endIslandIndex = startIslandIndex; endIslandIndex < numElem && dynamicCast($get_6(this$static.unionFind.elements, endIslandIndex), 28).id == islandId; ++endIslandIndex) {
        i = dynamicCast($get_6(this$static.unionFind.elements, endIslandIndex), 28).sz;
        colObj0 = dynamicCast((checkIndex(i, collisionObjects.size) , collisionObjects.array[i]), 17);
        $add_7(this$static.islandBodies, colObj0);
        !(colObj0.activationState1 != 2 && colObj0.activationState1 != 5) && (islandSleeping = true);
      }
      numIslandManifolds = 0;
      startManifold_idx = -1;
      if (startManifoldIndex < numManifolds) {
        curIslandId = getIslandId(dynamicCast($get_6(this$static.islandmanifold, startManifoldIndex), 16));
        if (curIslandId == islandId) {
          startManifold_idx = startManifoldIndex;
          for (endManifoldIndex = startManifoldIndex + 1; endManifoldIndex < numManifolds && islandId == getIslandId(dynamicCast($get_6(this$static.islandmanifold, endManifoldIndex), 16)); ++endManifoldIndex) {
          }
          numIslandManifolds = endManifoldIndex - startManifoldIndex;
        }
      }
      !islandSleeping && $processIsland(callback, this$static.islandmanifold, startManifold_idx, numIslandManifolds, islandId);
      numIslandManifolds != 0 && (startManifoldIndex = endManifoldIndex);
      $clear(this$static.islandBodies);
    }
    $clear(this$static.islandmanifold);
  }
   finally {
  }
}

function $findUnions(this$static, colWorld){
  var colObj0, colObj1, collisionPair, i, pairPtr;
  pairPtr = colWorld.broadphasePairCache.pairCache.overlappingPairArray;
  for (i = 0; i < pairPtr.size; ++i) {
    collisionPair = dynamicCast($get_0(pairPtr, i), 14);
    colObj0 = collisionPair.pProxy0.clientObject;
    colObj1 = collisionPair.pProxy1.clientObject;
    !!colObj0 && (colObj0.collisionFlags & 7) == 0 && !!colObj1 && (colObj1.collisionFlags & 7) == 0 && $unite(this$static.unionFind, colObj0.islandTag1, colObj1.islandTag1);
  }
}

function $storeIslandActivationState(this$static, colWorld){
  var collisionObject, i, index;
  index = 0;
  for (i = 0; i < colWorld.collisionObjects.size; ++i) {
    collisionObject = dynamicCast($get_6(colWorld.collisionObjects, i), 17);
    if ((collisionObject.collisionFlags & 7) == 0) {
      collisionObject.islandTag1 = $find(this$static.unionFind, index);
      collisionObject.companionId = -1;
    }
     else {
      collisionObject.islandTag1 = -1;
      collisionObject.companionId = -2;
    }
    ++index;
  }
}

function $updateActivationState(this$static, colWorld){
  var collisionObject, i, index;
  $reset(this$static.unionFind, colWorld.collisionObjects.size);
  index = 0;
  for (i = 0; i < colWorld.collisionObjects.size; ++i) {
    collisionObject = dynamicCast($get_6(colWorld.collisionObjects, i), 17);
    collisionObject.islandTag1 = index;
    collisionObject.companionId = -1;
    collisionObject.hitFraction = 1;
    ++index;
  }
  $findUnions(this$static, colWorld);
}

function getClass_42(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_SimulationIslandManager_2_classLit;
}

function getIslandId(lhs){
  $clinit_48();
  var islandId, rcolObj0, rcolObj1;
  rcolObj0 = lhs.body0;
  rcolObj1 = lhs.body1;
  islandId = rcolObj0.islandTag1 >= 0?rcolObj0.islandTag1:rcolObj1.islandTag1;
  return islandId;
}

function SimulationIslandManager(){
}

_ = SimulationIslandManager.prototype = new Object_0;
_.getClass$ = getClass_42;
_.typeId$ = 0;
var persistentManifoldComparator;
function $compare(lhs, rhs){
  return getIslandId(lhs) < getIslandId(rhs)?-1:1;
}

function compare_0(p0, p1){
  return $compare(dynamicCast(p0, 16), dynamicCast(p1, 16));
}

function getClass_43(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_SimulationIslandManager$1_2_classLit;
}

function SimulationIslandManager$1(){
}

_ = SimulationIslandManager$1.prototype = new Object_0;
_.compare = compare_0;
_.getClass$ = getClass_43;
_.typeId$ = 0;
function $init_5(this$static, mf, ci, col0, col1){
  this$static.dispatcher = ci.dispatcher1;
  this$static.manifoldPtr = mf;
  if (!this$static.manifoldPtr) {
    this$static.manifoldPtr = $getNewManifold(this$static.dispatcher, col0, col1);
    this$static.ownManifold = true;
  }
}

function calculateTimeOfImpact_4(body0, body1, dispatchInfo, resultOut){
  return 1;
}

function destroy_4(){
  if (this.ownManifold) {
    !!this.manifoldPtr && $releaseManifold(this.dispatcher, this.manifoldPtr);
    this.manifoldPtr = null;
  }
}

function getClass_44(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_SphereSphereCollisionAlgorithm_2_classLit;
}

function processCollision_4(col0, col1, dispatchInfo, resultOut){
  var diff, dist, len, normalOnSurfaceB, pos0, pos1, radius0, radius1, sphere0, sphere1, tmp, tmpTrans1, tmpTrans2;
  if (!this.manifoldPtr) {
    return;
  }
  tmpTrans1 = $Transform(new Transform);
  tmpTrans2 = $Transform(new Transform);
  resultOut.manifoldPtr = this.manifoldPtr;
  sphere0 = dynamicCast(col0.collisionShape, 26);
  sphere1 = dynamicCast(col1.collisionShape, 26);
  diff = $Vector3f_2(new Vector3f);
  $sub(diff, ($set_3(tmpTrans1, col0.worldTransform) , tmpTrans1).origin, ($set_3(tmpTrans2, col1.worldTransform) , tmpTrans2).origin);
  len = Math.sqrt(diff.x * diff.x + diff.y * diff.y + diff.z * diff.z);
  radius0 = sphere0.implicitShapeDimensions.x * sphere0.localScaling.x;
  radius1 = sphere1.implicitShapeDimensions.x * sphere1.localScaling.x;
  if (len > radius0 + radius1) {
    return;
  }
  dist = len - (radius0 + radius1);
  normalOnSurfaceB = $Vector3f_2(new Vector3f);
  normalOnSurfaceB.x = 1;
  normalOnSurfaceB.y = 0;
  normalOnSurfaceB.z = 0;
  len > 1.1920928955078125E-7 && (normalOnSurfaceB.x = 1 / len * diff.x , normalOnSurfaceB.y = 1 / len * diff.y , normalOnSurfaceB.z = 1 / len * diff.z , undefined);
  tmp = $Vector3f_2(new Vector3f);
  pos0 = $Vector3f_2(new Vector3f);
  tmp.x = radius0 * normalOnSurfaceB.x;
  tmp.y = radius0 * normalOnSurfaceB.y;
  tmp.z = radius0 * normalOnSurfaceB.z;
  $sub(pos0, ($set_3(tmpTrans1, col0.worldTransform) , tmpTrans1).origin, tmp);
  pos1 = $Vector3f_2(new Vector3f);
  tmp.x = radius1 * normalOnSurfaceB.x;
  tmp.y = radius1 * normalOnSurfaceB.y;
  tmp.z = radius1 * normalOnSurfaceB.z;
  $add_1(pos1, ($set_3(tmpTrans2, col1.worldTransform) , tmpTrans2).origin, tmp);
  $addContactPoint(resultOut, normalOnSurfaceB, pos1, dist);
}

function SphereSphereCollisionAlgorithm(){
}

_ = SphereSphereCollisionAlgorithm.prototype = new CollisionAlgorithm;
_.calculateTimeOfImpact = calculateTimeOfImpact_4;
_.destroy = destroy_4;
_.getClass$ = getClass_44;
_.processCollision = processCollision_4;
_.typeId$ = 28;
_.manifoldPtr = null;
_.ownManifold = false;
function $SphereSphereCollisionAlgorithm$CreateFunc(this$static){
  this$static.pool = get_1(Lcom_bulletphysics_gwt_client_collision_dispatch_SphereSphereCollisionAlgorithm_2_classLit, ($clinit_125() , sphereSphereCollisionAlgorithmFactory));
  return this$static;
}

function createCollisionAlgorithm_6(ci, body0, body1){
  var algo;
  algo = dynamicCast($get_1(this.pool), 27);
  $init_5(algo, null, ci, body0, body1);
  return algo;
}

function getClass_45(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_SphereSphereCollisionAlgorithm$CreateFunc_2_classLit;
}

function releaseCollisionAlgorithm_6(algo){
  $add_7(this.pool.list, dynamicCast(algo, 27));
}

function SphereSphereCollisionAlgorithm$CreateFunc(){
}

_ = SphereSphereCollisionAlgorithm$CreateFunc.prototype = new CollisionAlgorithmCreateFunc;
_.createCollisionAlgorithm = createCollisionAlgorithm_6;
_.getClass$ = getClass_45;
_.releaseCollisionAlgorithm = releaseCollisionAlgorithm_6;
_.typeId$ = 29;
--></script>
<script><!--
function $clinit_53(){
  $clinit_53 = nullMethod;
  elementComparator = new UnionFind$1;
}

function $UnionFind(this$static){
  $clinit_53();
  this$static.elements = $ArrayList(new ArrayList);
  return this$static;
}

function $find(this$static, x){
  while (x != dynamicCast($get_6(this$static.elements, x), 28).id) {
    dynamicCast($get_6(this$static.elements, x), 28).id = dynamicCast($get_6(this$static.elements, dynamicCast($get_6(this$static.elements, x), 28).id), 28).id;
    x = dynamicCast($get_6(this$static.elements, x), 28).id;
  }
  return x;
}

function $reset(this$static, N){
  var i;
  resize_0(this$static.elements, N, Lcom_bulletphysics_gwt_client_collision_dispatch_UnionFind$Element_2_classLit, $clinit_125());
  for (i = 0; i < N; ++i) {
    dynamicCast($get_6(this$static.elements, i), 28).id = i;
    dynamicCast($get_6(this$static.elements, i), 28).sz = 1;
  }
}

function $sortIslands(this$static){
  var i, numElements;
  numElements = this$static.elements.size;
  for (i = 0; i < numElements; ++i) {
    dynamicCast($get_6(this$static.elements, i), 28).id = $find(this$static, i);
    dynamicCast($get_6(this$static.elements, i), 28).sz = i;
  }
  quickSort(this$static.elements, elementComparator);
}

function $unite(this$static, p, q){
  var i, j;
  i = $find(this$static, p);
  j = $find(this$static, q);
  if (i == j) {
    return;
  }
  dynamicCast($get_6(this$static.elements, i), 28).id = j;
  dynamicCast($get_6(this$static.elements, j), 28).sz += dynamicCast($get_6(this$static.elements, i), 28).sz;
}

function getClass_46(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_UnionFind_2_classLit;
}

function UnionFind(){
}

_ = UnionFind.prototype = new Object_0;
_.getClass$ = getClass_46;
_.typeId$ = 0;
var elementComparator;
function compare_1(p0, p1){
  return dynamicCast(p0, 28).id < dynamicCast(p1, 28).id?-1:1;
}

function getClass_47(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_UnionFind$1_2_classLit;
}

function UnionFind$1(){
}

_ = UnionFind$1.prototype = new Object_0;
_.compare = compare_1;
_.getClass$ = getClass_47;
_.typeId$ = 0;
function getClass_48(){
  return Lcom_bulletphysics_gwt_client_collision_dispatch_UnionFind$Element_2_classLit;
}

function UnionFind$Element(){
}

_ = UnionFind$Element.prototype = new Object_0;
_.getClass$ = getClass_48;
_.typeId$ = 30;
_.id = 0;
_.sz = 0;
function $ConvexCast$CastResult(this$static){
  $$init_48(new Transform);
  $$init_48(new Transform);
  this$static.normal = $Vector3f_2(new Vector3f);
  this$static.hitPoint = $Vector3f_2(new Vector3f);
  return this$static;
}

function getClass_49(){
  return Lcom_bulletphysics_gwt_client_collision_narrowphase_ConvexCast$CastResult_2_classLit;
}

function ConvexCast$CastResult(){
}

_ = ConvexCast$CastResult.prototype = new Object_0;
_.getClass$ = getClass_49;
_.typeId$ = 0;
_.fraction = 1.0000000150474662E30;
function getClass_50(){
  return Lcom_bulletphysics_gwt_client_collision_narrowphase_DiscreteCollisionDetectorInterface_2_classLit;
}

function DiscreteCollisionDetectorInterface(){
}

_ = DiscreteCollisionDetectorInterface.prototype = new Object_0;
_.getClass$ = getClass_50;
_.typeId$ = 0;
function $DiscreteCollisionDetectorInterface$ClosestPointInput(this$static){
  this$static.transformA = $Transform(new Transform);
  this$static.transformB = $Transform(new Transform);
  this$static.maximumDistanceSquared = 3.4028234663852886E38;
  return this$static;
}

function getClass_51(){
  return Lcom_bulletphysics_gwt_client_collision_narrowphase_DiscreteCollisionDetectorInterface$ClosestPointInput_2_classLit;
}

function DiscreteCollisionDetectorInterface$ClosestPointInput(){
}

_ = DiscreteCollisionDetectorInterface$ClosestPointInput.prototype = new Object_0;
_.getClass$ = getClass_51;
_.typeId$ = 31;
_.maximumDistanceSquared = 0;
function $GjkConvexCast(this$static, convexA, convexB, simplexSolver){
  this$static.pointInputsPool = get_1(Lcom_bulletphysics_gwt_client_collision_narrowphase_DiscreteCollisionDetectorInterface$ClosestPointInput_2_classLit, ($clinit_125() , closestPointInputFactory));
  this$static.gjk = $GjkPairDetector(new GjkPairDetector);
  this$static.simplexSolver = simplexSolver;
  this$static.convexA = convexA;
  this$static.convexB = convexB;
  return this$static;
}

function $calcTimeOfImpact(this$static, fromA, toA, fromB, toB, result){
  var c, dLambda, dist, hasResult, identityTrans, input, lambda, lastLambda, linVelA, linVelB, n, numIter, pointCollector, projectedLinearVelocity, r, v;
  $reset_0(this$static.simplexSolver);
  linVelA = $Vector3f_2(new Vector3f);
  linVelB = $Vector3f_2(new Vector3f);
  $sub(linVelA, toA.origin, fromA.origin);
  $sub(linVelB, toB.origin, fromB.origin);
  lambda = 0;
  v = $Vector3f_2(new Vector3f);
  v.x = 1;
  v.y = 0;
  v.z = 0;
  n = $Vector3f_2(new Vector3f);
  n.x = 0;
  n.y = 0;
  n.z = 0;
  hasResult = false;
  c = $Vector3f_2(new Vector3f);
  r = $Vector3f_2(new Vector3f);
  $sub(r, linVelA, linVelB);
  lastLambda = lambda;
  numIter = 0;
  identityTrans = $Transform(new Transform);
  $setIdentity_0(identityTrans.basis);
  $set_8(identityTrans.origin, 0, 0, 0);
  pointCollector = $PointCollector(new PointCollector);
  $init_7(this$static.gjk, this$static.convexA, this$static.convexB, this$static.simplexSolver, null);
  input = dynamicCast($get_1(this$static.pointInputsPool), 22);
  input.maximumDistanceSquared = 3.4028234663852886E38;
  try {
    $set_3(input.transformA, fromA);
    $set_3(input.transformB, fromB);
    $getClosestPoints(this$static.gjk, input, pointCollector);
    hasResult = pointCollector.hasResult;
    $set_9(c, pointCollector.pointInWorld);
    if (hasResult) {
      dist = pointCollector.distance;
      $set_9(n, pointCollector.normalOnBInWorld);
      while (dist > 0.0010000000474974513) {
        ++numIter;
        if (numIter > 32) {
          return false;
        }
        dLambda = 0;
        projectedLinearVelocity = r.x * n.x + r.y * n.y + r.z * n.z;
        dLambda = dist / projectedLinearVelocity;
        lambda = lambda - dLambda;
        if (lambda > 1) {
          return false;
        }
        if (lambda < 0) {
          return false;
        }
        if (lambda <= lastLambda) {
          return false;
        }
        lastLambda = lambda;
        setInterpolate3(input.transformA.origin, fromA.origin, toA.origin, lambda);
        setInterpolate3(input.transformB.origin, fromB.origin, toB.origin, lambda);
        $getClosestPoints(this$static.gjk, input, pointCollector);
        if (pointCollector.hasResult) {
          if (pointCollector.distance < 0) {
            result.fraction = lastLambda;
            $set_9(n, pointCollector.normalOnBInWorld);
            $set_9(result.normal, n);
            $set_9(result.hitPoint, pointCollector.pointInWorld);
            return true;
          }
          $set_9(c, pointCollector.pointInWorld);
          $set_9(n, pointCollector.normalOnBInWorld);
          dist = pointCollector.distance;
        }
         else {
          return false;
        }
      }
      if (n.x * r.x + n.y * r.y + n.z * r.z >= 0) {
        return false;
      }
      result.fraction = lambda;
      $set_9(result.normal, n);
      $set_9(result.hitPoint, c);
      return true;
    }
    return false;
  }
   finally {
    $add_7(this$static.pointInputsPool.list, input);
  }
}

function getClass_52(){
  return Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkConvexCast_2_classLit;
}

function GjkConvexCast(){
}

_ = GjkConvexCast.prototype = new Object_0;
_.getClass$ = getClass_52;
_.typeId$ = 0;
_.convexA = null;
_.convexB = null;
_.simplexSolver = null;
function $GjkEpaPenetrationDepthSolver(this$static){
  this$static.gjkEpaSolver = $GjkEpaSolver(new GjkEpaSolver);
  return this$static;
}

function $calcPenDepth(this$static, pConvexA, pConvexB, transformA, transformB, wWitnessOnA, wWitnessOnB){
  var results;
  results = $GjkEpaSolver$Results(new GjkEpaSolver$Results);
  if ($collide(this$static.gjkEpaSolver, pConvexA, transformA, pConvexB, transformB, 0, results)) {
    $set_9(wWitnessOnA, results.witnesses[0]);
    $set_9(wWitnessOnB, results.witnesses[1]);
    return true;
  }
  return false;
}

function getClass_53(){
  return Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaPenetrationDepthSolver_2_classLit;
}

function GjkEpaPenetrationDepthSolver(){
}

_ = GjkEpaPenetrationDepthSolver.prototype = new Object_0;
_.getClass$ = getClass_53;
_.typeId$ = 0;
function $clinit_64(){
  $clinit_64 = nullMethod;
  mod3 = initValues(_3I_classLit, 150, -1, [0, 1, 2, 0, 1]);
  tetrahedron_fidx = initValues(_3_3I_classLit, 164, 8, [initValues(_3I_classLit, 150, -1, [2, 1, 0]), initValues(_3I_classLit, 150, -1, [3, 0, 1]), initValues(_3I_classLit, 150, -1, [3, 1, 2]), initValues(_3I_classLit, 150, -1, [3, 2, 0])]);
  tetrahedron_eidx = initValues(_3_3I_classLit, 164, 8, [initValues(_3I_classLit, 150, -1, [0, 0, 2, 1]), initValues(_3I_classLit, 150, -1, [0, 1, 1, 1]), initValues(_3I_classLit, 150, -1, [0, 2, 3, 1]), initValues(_3I_classLit, 150, -1, [1, 0, 3, 2]), initValues(_3I_classLit, 150, -1, [2, 0, 1, 2]), initValues(_3I_classLit, 150, -1, [3, 0, 2, 2])]);
  hexahedron_fidx = initValues(_3_3I_classLit, 164, 8, [initValues(_3I_classLit, 150, -1, [2, 0, 4]), initValues(_3I_classLit, 150, -1, [4, 1, 2]), initValues(_3I_classLit, 150, -1, [1, 4, 0]), initValues(_3I_classLit, 150, -1, [0, 3, 1]), initValues(_3I_classLit, 150, -1, [0, 2, 3]), initValues(_3I_classLit, 150, -1, [1, 3, 2])]);
  hexahedron_eidx = initValues(_3_3I_classLit, 164, 8, [initValues(_3I_classLit, 150, -1, [0, 0, 4, 0]), initValues(_3I_classLit, 150, -1, [0, 1, 2, 1]), initValues(_3I_classLit, 150, -1, [0, 2, 1, 2]), initValues(_3I_classLit, 150, -1, [1, 1, 5, 2]), initValues(_3I_classLit, 150, -1, [1, 0, 2, 0]), initValues(_3I_classLit, 150, -1, [2, 2, 3, 2]), initValues(_3I_classLit, 150, -1, [3, 1, 5, 0]), initValues(_3I_classLit, 150, -1, [3, 0, 4, 2]), initValues(_3I_classLit, 150, -1, [5, 1, 4, 1])]);
}

function $GjkEpaSolver(this$static){
  $clinit_64();
  this$static.floatArrays = get(F_classLit);
  this$static.stackMkv = $ObjectStackList(new ObjectStackList, ($clinit_125() , mkvFactory));
  this$static.stackHe = $ObjectStackList(new ObjectStackList, heFactory);
  this$static.stackFace = $ObjectStackList(new ObjectStackList, faceFactory);
  this$static.gjk = $GjkEpaSolver$GJK(new GjkEpaSolver$GJK, this$static);
  return this$static;
}

function $collide(this$static, shape0, wtrs0, shape1, wtrs1, radialmargin, results){
  var collide, epa, pd;
  $set_8(results.witnesses[0], 0, 0, 0);
  $set_8(results.witnesses[1], 0, 0, 0);
  $set_8(results.normal, 0, 0, 0);
  $clinit_71();
  $init_6(this$static.gjk, wtrs0.basis, wtrs0.origin, shape0, wtrs1.basis, wtrs1.origin, shape1, radialmargin + 0.0010000000474974513);
  try {
    collide = $SearchOrigin(this$static.gjk);
    if (collide) {
      epa = $GjkEpaSolver$EPA(new GjkEpaSolver$EPA, this$static.gjk, this$static);
      pd = $EvaluatePD(epa, 0.0010000000474974513);
      if (pd > 0) {
        $set_9(results.normal, epa.normal);
        $set_9(results.witnesses[0], epa.nearest[0]);
        $set_9(results.witnesses[1], epa.nearest[1]);
        return true;
      }
       else {
        epa.failed && $clinit_71();
      }
    }
     else {
      this$static.gjk.failed && $clinit_71();
    }
    return false;
  }
   finally {
    $popStack(this$static.gjk.this$0);
  }
}

function $popStack(this$static){
  $pop(this$static.stackMkv);
  $pop(this$static.stackHe);
  $pop(this$static.stackFace);
}

function $pushStack(this$static){
  $push(this$static.stackMkv);
  $push(this$static.stackHe);
  $push(this$static.stackFace);
}

function getClass_54(){
  return Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver_2_classLit;
}

function GjkEpaSolver(){
}

_ = GjkEpaSolver.prototype = new Object_0;
_.getClass$ = getClass_54;
_.typeId$ = 0;
var hexahedron_eidx, hexahedron_fidx, mod3, tetrahedron_eidx, tetrahedron_fidx;
function $$init_24(this$static){
  var i, j;
  this$static.features = initDims_0([_3_3Lcom_bulletphysics_gwt_client_vecmath_Vector3f_2_classLit, _3Lcom_bulletphysics_gwt_client_vecmath_Vector3f_2_classLit], [162, 143], [6, 53], [2, 3], 0, 2, 0);
  this$static.nearest = initValues(_3Lcom_bulletphysics_gwt_client_vecmath_Vector3f_2_classLit, 143, 53, [$Vector3f_2(new Vector3f), $Vector3f_2(new Vector3f)]);
  this$static.normal = $Vector3f_2(new Vector3f);
  for (i = 0; i < this$static.features.length; ++i) {
    for (j = 0; j < this$static.features[i].length; ++j) {
      this$static.features[i][j] = $Vector3f_2(new Vector3f);
    }
  }
}

function $BuildHorizon(this$static, markid, w, f, e, cf, ff){
  var e1, e2, ne, nf;
  ne = 0;
  if (f.mark != markid) {
    e1 = ($clinit_64() , mod3)[e + 1];
    if ($dot(f.n, w.w) + f.d > 0) {
      nf = $NewFace(this$static, f.v[e1], f.v[e], w);
      nf.f[0] = f;
      f.e[e] = 0;
      f.f[e] = nf;
      nf.e[0] = e;
      cf[0]?(cf[0].f[1] = nf , nf.e[2] = 1 , nf.f[2] = cf[0] , cf[0].e[1] = 2 , undefined):(ff[0] = nf);
      cf[0] = nf;
      ne = 1;
    }
     else {
      e2 = mod3[e + 2];
      $Detach(this$static, f);
      f.mark = markid;
      ne += $BuildHorizon(this$static, markid, w, f.f[e1], f.e[e1], cf, ff);
      ne += $BuildHorizon(this$static, markid, w, f.f[e2], f.e[e2], cf, ff);
    }
  }
  return ne;
}

function $Detach(this$static, face){
  if (!!face.prev || !!face.next) {
    --this$static.nfaces;
    if (face == this$static.root_0) {
      this$static.root_0 = face.next;
      this$static.root_0.prev = null;
    }
     else {
      if (!face.next) {
        face.prev.next = null;
      }
       else {
        face.prev.next = face.next;
        face.next.prev = face.prev;
      }
    }
    face.prev = face.next = null;
  }
}

function $EvaluatePD(this$static, accuracy){
  var b, basefaces, basemkv, bestface, bf, cf, d, ff, i, j, markid, neidx, nf, nfidx, peidx_index, peidx_ptr, pfidx_index, pfidx_ptr, s, tmp, tmp1, tmp2, tmp3, w, v;
  $pushStack(this$static.this$0);
  try {
    tmp = $Vector3f_2(new Vector3f);
    bestface = null;
    markid = 1;
    this$static.depth = -3.4028234663852886E38;
    $set_8(this$static.normal, 0, 0, 0);
    this$static.root_0 = null;
    this$static.nfaces = 0;
    this$static.iterations = 0;
    this$static.failed = false;
    if ($EncloseOrigin(this$static.gjk)) {
      pfidx_ptr = null;
      pfidx_index = 0;
      nfidx = 0;
      peidx_ptr = null;
      peidx_index = 0;
      neidx = 0;
      basemkv = initDim(_3Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$Mkv_2_classLit, 133, 31, 5, 0);
      basefaces = initDim(_3Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$Face_2_classLit, 131, 30, 6, 0);
      switch (this$static.gjk.order) {
        case 3:
          {
            pfidx_ptr = ($clinit_64() , tetrahedron_fidx);
            pfidx_index = 0;
            nfidx = 4;
            peidx_ptr = tetrahedron_eidx;
            peidx_index = 0;
            neidx = 6;
          }

          break;
        case 4:
          {
            pfidx_ptr = ($clinit_64() , hexahedron_fidx);
            pfidx_index = 0;
            nfidx = 6;
            peidx_ptr = hexahedron_eidx;
            peidx_index = 0;
            neidx = 9;
          }

      }
      for (i = 0; i <= this$static.gjk.order; ++i) {
        basemkv[i] = $GjkEpaSolver$Mkv(new GjkEpaSolver$Mkv);
        $set_1(basemkv[i], this$static.gjk.simplex[i]);
      }
      for (i = 0; i < nfidx; ++i , ++pfidx_index) {
        basefaces[i] = $NewFace(this$static, basemkv[pfidx_ptr[pfidx_index][0]], basemkv[pfidx_ptr[pfidx_index][1]], basemkv[pfidx_ptr[pfidx_index][2]]);
      }
      for (i = 0; i < neidx; ++i , ++peidx_index) {
        basefaces[peidx_ptr[peidx_index][0]].f[peidx_ptr[peidx_index][1]] = basefaces[peidx_ptr[peidx_index][2]];
        basefaces[peidx_ptr[peidx_index][2]].e[peidx_ptr[peidx_index][3]] = peidx_ptr[peidx_index][1];
        basefaces[peidx_ptr[peidx_index][2]].f[peidx_ptr[peidx_index][3]] = basefaces[peidx_ptr[peidx_index][0]];
        basefaces[peidx_ptr[peidx_index][0]].e[peidx_ptr[peidx_index][1]] = peidx_ptr[peidx_index][3];
      }
    }
    if (0 == this$static.nfaces) {
      return this$static.depth;
    }
    for (; this$static.iterations < 256; ++this$static.iterations) {
      bf = $FindBest(this$static);
      if (bf) {
        $negate(tmp, bf.n);
        w = (v = dynamicCast($get_2(this$static.this$0.stackMkv), 31) , $Support_0(this$static.gjk, tmp, v) , v);
        d = $dot(bf.n, w.w) + bf.d;
        bestface = bf;
        if (d < -accuracy) {
          cf = initValues(_3Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$Face_2_classLit, 131, 30, [null]);
          ff = initValues(_3Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$Face_2_classLit, 131, 30, [null]);
          nf = 0;
          $Detach(this$static, bf);
          bf.mark = ++markid;
          for (i = 0; i < 3; ++i) {
            nf += $BuildHorizon(this$static, markid, w, bf.f[i], bf.e[i], cf, ff);
          }
          if (nf <= 2) {
            break;
          }
          cf[0].f[1] = ff[0];
          ff[0].e[2] = 1;
          ff[0].f[2] = cf[0];
          cf[0].e[1] = 2;
        }
         else {
          break;
        }
      }
       else {
        break;
      }
    }
    if (bestface) {
      b = $GetCoordinates(this$static, bestface, $Vector3f_2(new Vector3f));
      $set_9(this$static.normal, bestface.n);
      this$static.depth = max_0(0, bestface.d);
      for (i = 0; i < 2; ++i) {
        s = i != 0?-1:1;
        for (j = 0; j < 3; ++j) {
          $scale(tmp, s, bestface.v[j].r);
          $LocalSupport(this$static.gjk, tmp, i, this$static.features[i][j]);
        }
      }
      tmp1 = $Vector3f_2(new Vector3f);
      tmp2 = $Vector3f_2(new Vector3f);
      tmp3 = $Vector3f_2(new Vector3f);
      $scale(tmp1, b.x, this$static.features[0][0]);
      $scale(tmp2, b.y, this$static.features[0][1]);
      $scale(tmp3, b.z, this$static.features[0][2]);
      add(this$static.nearest[0], tmp1, tmp2, tmp3);
      $scale(tmp1, b.x, this$static.features[1][0]);
      $scale(tmp2, b.y, this$static.features[1][1]);
      $scale(tmp3, b.z, this$static.features[1][2]);
      add(this$static.nearest[1], tmp1, tmp2, tmp3);
    }
     else {
      this$static.failed = true;
    }
    return this$static.depth;
  }
   finally {
    $popStack(this$static.this$0);
  }
}

function $FindBest(this$static){
  var bd, bf, cf;
  bf = null;
  if (this$static.root_0) {
    cf = this$static.root_0;
    bd = 3.4028234663852886E38;
    do {
      if (cf.d < bd) {
        bd = cf.d;
        bf = cf;
      }
    }
     while (cf = cf.next);
  }
  return bf;
}

function $GetCoordinates(this$static, face, out){
  var a, o, sm, tmp, tmp1, tmp2;
  tmp = $Vector3f_2(new Vector3f);
  tmp1 = $Vector3f_2(new Vector3f);
  tmp2 = $Vector3f_2(new Vector3f);
  o = $Vector3f_2(new Vector3f);
  $scale(o, -face.d, face.n);
  a = dynamicCast($getFixed(this$static.this$0.floatArrays, 3), 29);
  $sub(tmp1, face.v[0].w, o);
  $sub(tmp2, face.v[1].w, o);
  $cross(tmp, tmp1, tmp2);
  a[0] = Math.sqrt(tmp.x * tmp.x + tmp.y * tmp.y + tmp.z * tmp.z);
  $sub(tmp1, face.v[1].w, o);
  $sub(tmp2, face.v[2].w, o);
  $cross(tmp, tmp1, tmp2);
  a[1] = Math.sqrt(tmp.x * tmp.x + tmp.y * tmp.y + tmp.z * tmp.z);
  $sub(tmp1, face.v[2].w, o);
  $sub(tmp2, face.v[0].w, o);
  $cross(tmp, tmp1, tmp2);
  a[2] = Math.sqrt(tmp.x * tmp.x + tmp.y * tmp.y + tmp.z * tmp.z);
  sm = a[0] + a[1] + a[2];
  out.x = a[1];
  out.y = a[2];
  out.z = a[0];
  out.x *= 1 / (sm > 0?sm:1);
  out.y *= 1 / (sm > 0?sm:1);
  out.z *= 1 / (sm > 0?sm:1);
  $release(this$static.this$0.floatArrays, a);
  return out;
}

function $GjkEpaSolver$EPA(this$static, pgjk, this$0){
  this$static.this$0 = this$0;
  $$init_24(this$static);
  this$static.gjk = pgjk;
  return this$static;
}

function $NewFace(this$static, a, b, c){
  var pf, len, nrm, tmp1, tmp2, tmp3, valid;
  pf = dynamicCast($get_2(this$static.this$0.stackFace), 30);
  if (tmp1 = $Vector3f_2(new Vector3f) , tmp2 = $Vector3f_2(new Vector3f) , tmp3 = $Vector3f_2(new Vector3f) , nrm = $Vector3f_2(new Vector3f) , $sub(tmp1, b.w, a.w) , $sub(tmp2, c.w, a.w) , $cross(nrm, tmp1, tmp2) , len = Math.sqrt(nrm.x * nrm.x + nrm.y * nrm.y + nrm.z * nrm.z) , $cross(tmp1, a.w, b.w) , $cross(tmp2, b.w, c.w) , $cross(tmp3, c.w, a.w) , valid = tmp1.x * nrm.x + tmp1.y * nrm.y + tmp1.z * nrm.z >= -0.009999999776482582 && tmp2.x * nrm.x + tmp2.y * nrm.y + tmp2.z * nrm.z >= -0.009999999776482582 && tmp3.x * nrm.x + tmp3.y * nrm.y + tmp3.z * nrm.z >= -0.009999999776482582 , pf.v[0] = a , pf.v[1] = b , pf.v[2] = c , pf.mark = 0 , $scale(pf.n, 1 / (len > 0?len:3.4028234663852886E38), nrm) , pf.d = max_0(0, -$dot(pf.n, a.w)) , valid) {
    !!this$static.root_0 && (this$static.root_0.prev = pf);
    pf.prev = null;
    pf.next = this$static.root_0;
    this$static.root_0 = pf;
    ++this$static.nfaces;
  }
   else {
    pf.prev = pf.next = null;
  }
  return pf;
}

function getClass_55(){
  return Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$EPA_2_classLit;
}

function GjkEpaSolver$EPA(){
}

_ = GjkEpaSolver$EPA.prototype = new Object_0;
_.getClass$ = getClass_55;
_.typeId$ = 0;
_.depth = 0;
_.failed = false;
_.gjk = null;
_.iterations = 0;
_.nfaces = 0;
_.root_0 = null;
_.this$0 = null;
function $GjkEpaSolver$Face(this$static){
  this$static.v = initDim(_3Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$Mkv_2_classLit, 133, 31, 3, 0);
  this$static.f = initDim(_3Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$Face_2_classLit, 131, 30, 3, 0);
  this$static.e = initDim(_3I_classLit, 150, -1, 3, 1);
  this$static.n = $Vector3f_2(new Vector3f);
  return this$static;
}

function getClass_56(){
  return Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$Face_2_classLit;
}

function GjkEpaSolver$Face(){
}

_ = GjkEpaSolver$Face.prototype = new Object_0;
_.getClass$ = getClass_56;
_.typeId$ = 32;
_.d = 0;
_.mark = 0;
_.next = null;
_.prev = null;
function $$init_26(this$static){
  var i;
  this$static.table = initDim(_3Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$He_2_classLit, 132, 33, 64, 0);
  this$static.wrotations = initValues(_3Lcom_bulletphysics_gwt_client_vecmath_Matrix3f_2_classLit, 142, 52, [$Matrix3f_0(new Matrix3f), $Matrix3f_0(new Matrix3f)]);
  this$static.positions = initValues(_3Lcom_bulletphysics_gwt_client_vecmath_Vector3f_2_classLit, 143, 53, [$Vector3f_2(new Vector3f), $Vector3f_2(new Vector3f)]);
  this$static.shapes = initDim(_3Lcom_bulletphysics_gwt_client_collision_shapes_ConvexShape_2_classLit, 137, 21, 2, 0);
  this$static.simplex = initDim(_3Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$Mkv_2_classLit, 133, 31, 5, 0);
  this$static.ray = $Vector3f_2(new Vector3f);
  for (i = 0; i < this$static.simplex.length; ++i)
    this$static.simplex[i] = $GjkEpaSolver$Mkv(new GjkEpaSolver$Mkv);
}

function $EncloseOrigin(this$static){
  var ab, b, m, n, r, tmp, tmp1, tmp2, tmpQuat, w, d, s;
  tmp = $Vector3f_2(new Vector3f);
  tmp1 = $Vector3f_2(new Vector3f);
  tmp2 = $Vector3f_2(new Vector3f);
  switch (this$static.order) {
    case 1:
      {
        ab = $Vector3f_2(new Vector3f);
        $sub(ab, this$static.simplex[1].w, this$static.simplex[0].w);
        b = initValues(_3Lcom_bulletphysics_gwt_client_vecmath_Vector3f_2_classLit, 143, 53, [$Vector3f_2(new Vector3f), $Vector3f_2(new Vector3f), $Vector3f_2(new Vector3f)]);
        b[0].x = 1;
        b[0].y = 0;
        b[0].z = 0;
        b[1].x = 0;
        b[1].y = 1;
        b[1].z = 0;
        b[2].x = 0;
        b[2].y = 0;
        b[2].z = 1;
        $cross(b[0], ab, b[0]);
        $cross(b[1], ab, b[1]);
        $cross(b[2], ab, b[2]);
        m = initValues(_3F_classLit, 149, -1, [$lengthSquared(b[0]), $lengthSquared(b[1]), $lengthSquared(b[2])]);
        tmpQuat = $Quat4f(new Quat4f);
        $normalize_0(tmp, ab);
        d = Math.sqrt(tmp.x * tmp.x + tmp.y * tmp.y + tmp.z * tmp.z);
        s = Math.sin(2.094395160675049 * 0.5) / d;
        $set_7(tmpQuat, tmp.x * s, tmp.y * s, tmp.z * s, Math.cos(2.094395160675049 * 0.5));
        r = $Matrix3f_0(new Matrix3f);
        setRotation(r, tmpQuat);
        w = $Vector3f_2(new Vector3f);
        w.x = b[m[0] > m[1]?m[0] > m[2]?0:2:m[1] > m[2]?1:2].x;
        w.y = b[m[0] > m[1]?m[0] > m[2]?0:2:m[1] > m[2]?1:2].y;
        w.z = b[m[0] > m[1]?m[0] > m[2]?0:2:m[1] > m[2]?1:2].z;
        $normalize_0(tmp, w);
        $Support_0(this$static, tmp, this$static.simplex[4]);
        $transform_0(r, w);
        $normalize_0(tmp, w);
        $Support_0(this$static, tmp, this$static.simplex[2]);
        $transform_0(r, w);
        $normalize_0(tmp, w);
        $Support_0(this$static, tmp, this$static.simplex[3]);
        $transform_0(r, w);
        this$static.order = 4;
        return true;
      }

    case 2:
      {
        $sub(tmp1, this$static.simplex[1].w, this$static.simplex[0].w);
        $sub(tmp2, this$static.simplex[2].w, this$static.simplex[0].w);
        n = $Vector3f_2(new Vector3f);
        $cross(n, tmp1, tmp2);
        $normalize_1(n);
        $Support_0(this$static, n, this$static.simplex[3]);
        $negate(tmp, n);
        $Support_0(this$static, tmp, this$static.simplex[4]);
        this$static.order = 4;
        return true;
      }

    case 3:
      return true;
    case 4:
      return true;
  }
  return false;
}

function $FetchSupport(this$static){
  var e, h;
  h = $Hash(this$static.ray);
  e = this$static.table[h];
  while (e) {
    if ($equals_2(e.v, this$static.ray)) {
      --this$static.order;
      return false;
    }
     else {
      e = e.n;
    }
  }
  e = dynamicCast($get_2(this$static.this$0.stackHe), 33);
  $set_9(e.v, this$static.ray);
  e.n = this$static.table[h];
  this$static.table[h] = e;
  $Support_0(this$static, this$static.ray, this$static.simplex[++this$static.order]);
  return $dot(this$static.ray, this$static.simplex[this$static.order].w) > 0;
}

function $GjkEpaSolver$GJK(this$static, this$0){
  this$static.this$0 = this$0;
  $$init_26(this$static);
  return this$static;
}

function $Hash(v){
  var h;
  h = ~~Math.max(Math.min(v.x * 15461, 2147483647), -2147483648) ^ ~~Math.max(Math.min(v.y * 83003, 2147483647), -2147483648) ^ ~~Math.max(Math.min(v.z * 15473, 2147483647), -2147483648);
  return h * 169639 & 63;
}

function $LocalSupport(this$static, d, i, out){
  var tmp;
  tmp = $Vector3f_2(new Vector3f);
  transposeTransform(tmp, d, this$static.wrotations[i]);
  this$static.shapes[i].localGetSupportingVertex(tmp, out);
  $transform_0(this$static.wrotations[i], out);
  $add_2(out, this$static.positions[i]);
  return out;
}

function $SearchOrigin(this$static){
  var tmp;
  tmp = $Vector3f_2(new Vector3f);
  tmp.x = 1;
  tmp.y = 0;
  tmp.z = 0;
  return $SearchOrigin_0(this$static, tmp);
}

function $SearchOrigin_0(this$static, initray){
  var found, rl, tmp1, tmp2, tmp3, tmp4, tmp;
  tmp1 = $Vector3f_2(new Vector3f);
  tmp2 = $Vector3f_2(new Vector3f);
  tmp3 = $Vector3f_2(new Vector3f);
  tmp4 = $Vector3f_2(new Vector3f);
  this$static.iterations = 0;
  this$static.order = -1;
  this$static.failed = false;
  $set_9(this$static.ray, initray);
  $normalize_1(this$static.ray);
  fill_0(this$static.table, null);
  $FetchSupport(this$static);
  $negate(this$static.ray, this$static.simplex[0].w);
  for (; this$static.iterations < 128; ++this$static.iterations) {
    rl = $length(this$static.ray);
    $scale_0(this$static.ray, 1 / (rl > 0?rl:1));
    if ($FetchSupport(this$static)) {
      found = false;
      switch (this$static.order) {
        case 1:
          {
            $negate(tmp1, this$static.simplex[1].w);
            $sub(tmp2, this$static.simplex[0].w, this$static.simplex[1].w);
            found = $SolveSimplex2(this$static, tmp1, tmp2);
            break;
          }

        case 2:
          {
            $negate(tmp1, this$static.simplex[2].w);
            $sub(tmp2, this$static.simplex[1].w, this$static.simplex[2].w);
            $sub(tmp3, this$static.simplex[0].w, this$static.simplex[2].w);
            found = (tmp = $Vector3f_2(new Vector3f) , $cross(tmp, tmp2, tmp3) , $SolveSimplex3a(this$static, tmp1, tmp2, tmp3, tmp));
            break;
          }

        case 3:
          {
            $negate(tmp1, this$static.simplex[3].w);
            $sub(tmp2, this$static.simplex[2].w, this$static.simplex[3].w);
            $sub(tmp3, this$static.simplex[1].w, this$static.simplex[3].w);
            $sub(tmp4, this$static.simplex[0].w, this$static.simplex[3].w);
            found = $SolveSimplex4(this$static, tmp1, tmp2, tmp3, tmp4);
            break;
          }

      }
      if (found) {
        return true;
      }
    }
     else {
      return false;
    }
  }
  this$static.failed = true;
  return false;
}

function $SolveSimplex2(this$static, ao, ab){
  var cabo;
  if (ab.x * ao.x + ab.y * ao.y + ab.z * ao.z >= 0) {
    cabo = $Vector3f_2(new Vector3f);
    $cross(cabo, ab, ao);
    if (cabo.x * cabo.x + cabo.y * cabo.y + cabo.z * cabo.z > 9.99999905104687E-9) {
      $cross(this$static.ray, cabo, ab);
    }
     else {
      return true;
    }
  }
   else {
    this$static.order = 0;
    $set_1(this$static.simplex[0], this$static.simplex[1]);
    $set_9(this$static.ray, ao);
  }
  return false;
}

--></script>
<script><!--
function $SolveSimplex3a(this$static, ao, ab, ac, cabc){
  var d, swapTmp, tmp, tmp2;
  tmp = $Vector3f_2(new Vector3f);
  $cross(tmp, cabc, ab);
  tmp2 = $Vector3f_2(new Vector3f);
  $cross(tmp2, cabc, ac);
  if (tmp.x * ao.x + tmp.y * ao.y + tmp.z * ao.z < -9.999999747378752E-5) {
    this$static.order = 1;
    $set_1(this$static.simplex[0], this$static.simplex[1]);
    $set_1(this$static.simplex[1], this$static.simplex[2]);
    return $SolveSimplex2(this$static, ao, ab);
  }
   else if (tmp2.x * ao.x + tmp2.y * ao.y + tmp2.z * ao.z > 9.999999747378752E-5) {
    this$static.order = 1;
    $set_1(this$static.simplex[1], this$static.simplex[2]);
    return $SolveSimplex2(this$static, ao, ac);
  }
   else {
    d = cabc.x * ao.x + cabc.y * ao.y + cabc.z * ao.z;
    if ((d < 0?-d:d) > 9.999999747378752E-5) {
      if (d > 0) {
        $set_9(this$static.ray, cabc);
      }
       else {
        $negate(this$static.ray, cabc);
        swapTmp = $GjkEpaSolver$Mkv(new GjkEpaSolver$Mkv);
        $set_1(swapTmp, this$static.simplex[0]);
        $set_1(this$static.simplex[0], this$static.simplex[1]);
        $set_1(this$static.simplex[1], swapTmp);
      }
      return false;
    }
     else {
      return true;
    }
  }
}

function $SolveSimplex4(this$static, ao, ab, ac, ad){
  var crs, tmp, tmp2, tmp3;
  crs = $Vector3f_2(new Vector3f);
  tmp = $Vector3f_2(new Vector3f);
  $cross(tmp, ab, ac);
  tmp2 = $Vector3f_2(new Vector3f);
  $cross(tmp2, ac, ad);
  tmp3 = $Vector3f_2(new Vector3f);
  $cross(tmp3, ad, ab);
  if (tmp.x * ao.x + tmp.y * ao.y + tmp.z * ao.z > 9.999999747378752E-5) {
    crs.x = tmp.x;
    crs.y = tmp.y;
    crs.z = tmp.z;
    this$static.order = 2;
    $set_1(this$static.simplex[0], this$static.simplex[1]);
    $set_1(this$static.simplex[1], this$static.simplex[2]);
    $set_1(this$static.simplex[2], this$static.simplex[3]);
    return $SolveSimplex3a(this$static, ao, ab, ac, crs);
  }
   else if (tmp2.x * ao.x + tmp2.y * ao.y + tmp2.z * ao.z > 9.999999747378752E-5) {
    crs.x = tmp2.x;
    crs.y = tmp2.y;
    crs.z = tmp2.z;
    this$static.order = 2;
    $set_1(this$static.simplex[2], this$static.simplex[3]);
    return $SolveSimplex3a(this$static, ao, ac, ad, crs);
  }
   else if (tmp3.x * ao.x + tmp3.y * ao.y + tmp3.z * ao.z > 9.999999747378752E-5) {
    crs.x = tmp3.x;
    crs.y = tmp3.y;
    crs.z = tmp3.z;
    this$static.order = 2;
    $set_1(this$static.simplex[1], this$static.simplex[0]);
    $set_1(this$static.simplex[0], this$static.simplex[2]);
    $set_1(this$static.simplex[2], this$static.simplex[3]);
    return $SolveSimplex3a(this$static, ao, ad, ab, crs);
  }
   else {
    return true;
  }
}

function $Support_0(this$static, d, v){
  var tmp, tmp1, tmp2;
  $set_9(v.r, d);
  tmp1 = $LocalSupport(this$static, d, 0, $Vector3f_2(new Vector3f));
  tmp = $Vector3f_2(new Vector3f);
  tmp.x = d.x;
  tmp.y = d.y;
  tmp.z = d.z;
  tmp.x = -tmp.x;
  tmp.y = -tmp.y;
  tmp.z = -tmp.z;
  tmp2 = $LocalSupport(this$static, tmp, 1, $Vector3f_2(new Vector3f));
  $sub(v.w, tmp1, tmp2);
  $scaleAdd(v.w, this$static.margin, d, v.w);
}

function $init_6(this$static, wrot0, pos0, shape0, wrot1, pos1, shape1, pmargin){
  $pushStack(this$static.this$0);
  $set_6(this$static.wrotations[0], wrot0);
  $set_9(this$static.positions[0], pos0);
  setCheck(this$static.shapes, 0, shape0);
  $set_6(this$static.wrotations[1], wrot1);
  $set_9(this$static.positions[1], pos1);
  setCheck(this$static.shapes, 1, shape1);
  this$static.margin = pmargin;
  this$static.failed = false;
}

function getClass_57(){
  return Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$GJK_2_classLit;
}

function GjkEpaSolver$GJK(){
}

_ = GjkEpaSolver$GJK.prototype = new Object_0;
_.getClass$ = getClass_57;
_.typeId$ = 0;
_.failed = false;
_.iterations = 0;
_.margin = 0;
_.order = 0;
_.this$0 = null;
function $GjkEpaSolver$He(this$static){
  this$static.v = $Vector3f_2(new Vector3f);
  return this$static;
}

function getClass_58(){
  return Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$He_2_classLit;
}

function GjkEpaSolver$He(){
}

_ = GjkEpaSolver$He.prototype = new Object_0;
_.getClass$ = getClass_58;
_.typeId$ = 33;
_.n = null;
function $GjkEpaSolver$Mkv(this$static){
  this$static.w = $Vector3f_2(new Vector3f);
  this$static.r = $Vector3f_2(new Vector3f);
  return this$static;
}

function $set_1(this$static, m){
  $set_9(this$static.w, m.w);
  $set_9(this$static.r, m.r);
}

function getClass_59(){
  return Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$Mkv_2_classLit;
}

function GjkEpaSolver$Mkv(){
}

_ = GjkEpaSolver$Mkv.prototype = new Object_0;
_.getClass$ = getClass_59;
_.typeId$ = 34;
function $GjkEpaSolver$Results(this$static){
  this$static.witnesses = initValues(_3Lcom_bulletphysics_gwt_client_vecmath_Vector3f_2_classLit, 143, 53, [$Vector3f_2(new Vector3f), $Vector3f_2(new Vector3f)]);
  this$static.normal = $Vector3f_2(new Vector3f);
  return this$static;
}

function getClass_60(){
  return Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$Results_2_classLit;
}

function GjkEpaSolver$Results(){
}

_ = GjkEpaSolver$Results.prototype = new Object_0;
_.getClass$ = getClass_60;
_.typeId$ = 0;
function $clinit_71(){
  $clinit_71 = nullMethod;
  Separated = $GjkEpaSolver$ResultsStatus(new GjkEpaSolver$ResultsStatus, 'Separated', 0);
  Penetrating = $GjkEpaSolver$ResultsStatus(new GjkEpaSolver$ResultsStatus, 'Penetrating', 1);
  GJK_Failed = $GjkEpaSolver$ResultsStatus(new GjkEpaSolver$ResultsStatus, 'GJK_Failed', 2);
  EPA_Failed = $GjkEpaSolver$ResultsStatus(new GjkEpaSolver$ResultsStatus, 'EPA_Failed', 3);
}

function $GjkEpaSolver$ResultsStatus(this$static, enum$name, enum$ordinal){
  $clinit_71();
  this$static.name_0 = enum$name;
  this$static.ordinal = enum$ordinal;
  return this$static;
}

function getClass_61(){
  return Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$ResultsStatus_2_classLit;
}

function values_4(){
  $clinit_71();
  return initValues(_3Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$ResultsStatus_2_classLit, 134, 48, [Separated, Penetrating, GJK_Failed, EPA_Failed]);
}

function GjkEpaSolver$ResultsStatus(){
}

_ = GjkEpaSolver$ResultsStatus.prototype = new Enum;
_.getClass$ = getClass_61;
_.typeId$ = 35;
var EPA_Failed, GJK_Failed, Penetrating, Separated;
function $GjkPairDetector(this$static){
  this$static.cachedSeparatingAxis = $Vector3f_2(new Vector3f);
  return this$static;
}

function $getClosestPoints(this$static, input, output){
  var catchDegeneratePenetrationCase, check, checkPenetration, checkSimplex, delta, distance, distance2, f0, f1, isValid, isValid2, lenSqr, localTransA, localTransB, margin, marginA, marginB, normalInB, pInA, pWorld, pointOnA, pointOnB, positionOffset, previousSquaredDistance, qInB, qWorld, rlen, s, seperatingAxisInA, seperatingAxisInB, squaredDistance, tmp, tmpNormalInB, tmpPointOnA, tmpPointOnB, w;
  tmp = $Vector3f_2(new Vector3f);
  distance = 0;
  normalInB = $Vector3f_2(new Vector3f);
  normalInB.x = 0;
  normalInB.y = 0;
  normalInB.z = 0;
  pointOnA = $Vector3f_2(new Vector3f);
  pointOnB = $Vector3f_2(new Vector3f);
  localTransA = $Transform_0(new Transform, input.transformA);
  localTransB = $Transform_0(new Transform, input.transformB);
  positionOffset = $Vector3f_2(new Vector3f);
  $add_1(positionOffset, localTransA.origin, localTransB.origin);
  positionOffset.x *= 0.5;
  positionOffset.y *= 0.5;
  positionOffset.z *= 0.5;
  $sub_0(localTransA.origin, positionOffset);
  $sub_0(localTransB.origin, positionOffset);
  marginA = this$static.minkowskiA.getMargin();
  marginB = this$static.minkowskiB.getMargin();
  $clinit_1();
  ++gNumGjkChecks;
  if (this$static.ignoreMargin) {
    marginA = 0;
    marginB = 0;
  }
  this$static.curIter = 0;
  $set_8(this$static.cachedSeparatingAxis, 0, 1, 0);
  isValid = false;
  checkSimplex = false;
  checkPenetration = true;
  this$static.degenerateSimplex = 0;
  squaredDistance = 3.4028234663852886E38;
  delta = 0;
  margin = marginA + marginB;
  $reset_0(this$static.simplexSolver);
  seperatingAxisInA = $Vector3f_2(new Vector3f);
  seperatingAxisInB = $Vector3f_2(new Vector3f);
  pInA = $Vector3f_2(new Vector3f);
  qInB = $Vector3f_2(new Vector3f);
  pWorld = $Vector3f_2(new Vector3f);
  qWorld = $Vector3f_2(new Vector3f);
  w = $Vector3f_2(new Vector3f);
  tmpPointOnA = $Vector3f_2(new Vector3f);
  tmpPointOnB = $Vector3f_2(new Vector3f);
  tmpNormalInB = $Vector3f_2(new Vector3f);
  for (;;) {
    $negate(seperatingAxisInA, this$static.cachedSeparatingAxis);
    transposeTransform(seperatingAxisInA, seperatingAxisInA, input.transformA.basis);
    $set_9(seperatingAxisInB, this$static.cachedSeparatingAxis);
    transposeTransform(seperatingAxisInB, seperatingAxisInB, input.transformB.basis);
    this$static.minkowskiA.localGetSupportingVertexWithoutMargin(seperatingAxisInA, pInA);
    this$static.minkowskiB.localGetSupportingVertexWithoutMargin(seperatingAxisInB, qInB);
    pWorld.x = pInA.x;
    pWorld.y = pInA.y;
    pWorld.z = pInA.z;
    $transform_0(localTransA.basis, pWorld);
    $add_2(pWorld, localTransA.origin);
    qWorld.x = qInB.x;
    qWorld.y = qInB.y;
    qWorld.z = qInB.z;
    $transform_0(localTransB.basis, qWorld);
    $add_2(qWorld, localTransB.origin);
    $sub(w, pWorld, qWorld);
    delta = $dot(this$static.cachedSeparatingAxis, w);
    if (delta > 0 && delta * delta > squaredDistance * input.maximumDistanceSquared) {
      checkPenetration = false;
      break;
    }
    if ($inSimplex(this$static.simplexSolver, w)) {
      this$static.degenerateSimplex = 1;
      checkSimplex = true;
      break;
    }
    f0 = squaredDistance - delta;
    f1 = squaredDistance * 9.999999974752427E-7;
    if (f0 <= f1) {
      f0 <= 0 && (this$static.degenerateSimplex = 2);
      checkSimplex = true;
      break;
    }
    $addVertex(this$static.simplexSolver, w, pWorld, qWorld);
    if (!$closest(this$static.simplexSolver, this$static.cachedSeparatingAxis)) {
      this$static.degenerateSimplex = 3;
      checkSimplex = true;
      break;
    }
    if ($lengthSquared(this$static.cachedSeparatingAxis) < 9.999999974752427E-7) {
      this$static.degenerateSimplex = 6;
      checkSimplex = true;
      break;
    }
    previousSquaredDistance = squaredDistance;
    squaredDistance = $lengthSquared(this$static.cachedSeparatingAxis);
    if (previousSquaredDistance - squaredDistance <= 1.1920928955078125E-7 * previousSquaredDistance) {
      $backup_closest(this$static.simplexSolver, this$static.cachedSeparatingAxis);
      checkSimplex = true;
      break;
    }
    if (this$static.curIter++ > 1000) {
      break;
    }
    check = this$static.simplexSolver.numVertices != 4;
    if (!check) {
      $backup_closest(this$static.simplexSolver, this$static.cachedSeparatingAxis);
      break;
    }
  }
  if (checkSimplex) {
    $compute_points(this$static.simplexSolver, pointOnA, pointOnB);
    $sub(normalInB, pointOnA, pointOnB);
    lenSqr = $lengthSquared(this$static.cachedSeparatingAxis);
    lenSqr < 9.999999747378752E-5 && (this$static.degenerateSimplex = 5);
    if (lenSqr > 1.4210854715202004E-14) {
      rlen = 1 / Math.sqrt(lenSqr);
      normalInB.x *= rlen;
      normalInB.y *= rlen;
      normalInB.z *= rlen;
      s = Math.sqrt(squaredDistance);
      $scale(tmp, marginA / s, this$static.cachedSeparatingAxis);
      pointOnA.x -= tmp.x;
      pointOnA.y -= tmp.y;
      pointOnA.z -= tmp.z;
      $scale(tmp, marginB / s, this$static.cachedSeparatingAxis);
      pointOnB.x += tmp.x;
      pointOnB.y += tmp.y;
      pointOnB.z += tmp.z;
      distance = 1 / rlen - margin;
      isValid = true;
    }
  }
  catchDegeneratePenetrationCase = this$static.catchDegeneracies != 0 && !!this$static.penetrationDepthSolver && this$static.degenerateSimplex != 0 && distance + margin < 0.009999999776482582;
  if (checkPenetration && (!isValid || catchDegeneratePenetrationCase)) {
    if (this$static.penetrationDepthSolver) {
      ++gNumDeepPenetrationChecks;
      isValid2 = $calcPenDepth(this$static.penetrationDepthSolver, this$static.minkowskiA, this$static.minkowskiB, localTransA, localTransB, tmpPointOnA, tmpPointOnB);
      if (isValid2) {
        $sub(tmpNormalInB, tmpPointOnB, tmpPointOnA);
        lenSqr = tmpNormalInB.x * tmpNormalInB.x + tmpNormalInB.y * tmpNormalInB.y + tmpNormalInB.z * tmpNormalInB.z;
        if (lenSqr > 1.4210854715202004E-14) {
          $scale_0(tmpNormalInB, 1 / Math.sqrt(lenSqr));
          $sub(tmp, tmpPointOnA, tmpPointOnB);
          distance2 = -Math.sqrt(tmp.x * tmp.x + tmp.y * tmp.y + tmp.z * tmp.z);
          if (!isValid || distance2 < distance) {
            distance = distance2;
            pointOnA.x = tmpPointOnA.x;
            pointOnA.y = tmpPointOnA.y;
            pointOnA.z = tmpPointOnA.z;
            pointOnB.x = tmpPointOnB.x;
            pointOnB.y = tmpPointOnB.y;
            pointOnB.z = tmpPointOnB.z;
            normalInB.x = tmpNormalInB.x;
            normalInB.y = tmpNormalInB.y;
            normalInB.z = tmpNormalInB.z;
            isValid = true;
          }
        }
      }
    }
  }
  if (isValid) {
    $add_1(tmp, pointOnB, positionOffset);
    output.addContactPoint(normalInB, tmp, distance);
  }
}

function $init_7(this$static, objectA, objectB, simplexSolver, penetrationDepthSolver){
  $set_8(this$static.cachedSeparatingAxis, 0, 0, 1);
  this$static.ignoreMargin = false;
  this$static.catchDegeneracies = 1;
  this$static.penetrationDepthSolver = penetrationDepthSolver;
  this$static.simplexSolver = simplexSolver;
  this$static.minkowskiA = objectA;
  this$static.minkowskiB = objectB;
}

function getClass_62(){
  return Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkPairDetector_2_classLit;
}

function GjkPairDetector(){
}

_ = GjkPairDetector.prototype = new DiscreteCollisionDetectorInterface;
_.getClass$ = getClass_62;
_.typeId$ = 0;
_.catchDegeneracies = 0;
_.curIter = 0;
_.degenerateSimplex = 0;
_.ignoreMargin = false;
_.minkowskiA = null;
_.minkowskiB = null;
_.penetrationDepthSolver = null;
_.simplexSolver = null;
function $ManifoldPoint(this$static){
  this$static.localPointA = $Vector3f_2(new Vector3f);
  this$static.localPointB = $Vector3f_2(new Vector3f);
  this$static.positionWorldOnB = $Vector3f_2(new Vector3f);
  this$static.positionWorldOnA = $Vector3f_2(new Vector3f);
  this$static.normalWorldOnB = $Vector3f_2(new Vector3f);
  this$static.lateralFrictionDir1 = $Vector3f_2(new Vector3f);
  this$static.lateralFrictionDir2 = $Vector3f_2(new Vector3f);
  this$static.userPersistentData = null;
  this$static.appliedImpulse = 0;
  this$static.lateralFrictionInitialized = false;
  this$static.lifeTime = 0;
  return this$static;
}

function $set_2(this$static, p){
  $set_9(this$static.localPointA, p.localPointA);
  $set_9(this$static.localPointB, p.localPointB);
  $set_9(this$static.positionWorldOnA, p.positionWorldOnA);
  $set_9(this$static.positionWorldOnB, p.positionWorldOnB);
  $set_9(this$static.normalWorldOnB, p.normalWorldOnB);
  this$static.distance1 = p.distance1;
  this$static.combinedFriction = p.combinedFriction;
  this$static.combinedRestitution = p.combinedRestitution;
  this$static.partId0 = p.partId0;
  this$static.partId1 = p.partId1;
  this$static.index0 = p.index0;
  this$static.index1 = p.index1;
  this$static.userPersistentData = p.userPersistentData;
  this$static.appliedImpulse = p.appliedImpulse;
  this$static.lateralFrictionInitialized = p.lateralFrictionInitialized;
  this$static.appliedImpulseLateral1 = p.appliedImpulseLateral1;
  this$static.appliedImpulseLateral2 = p.appliedImpulseLateral2;
  this$static.lifeTime = p.lifeTime;
  $set_9(this$static.lateralFrictionDir1, p.lateralFrictionDir1);
  $set_9(this$static.lateralFrictionDir2, p.lateralFrictionDir2);
}

function getClass_63(){
  return Lcom_bulletphysics_gwt_client_collision_narrowphase_ManifoldPoint_2_classLit;
}

function ManifoldPoint(){
}

_ = ManifoldPoint.prototype = new Object_0;
_.getClass$ = getClass_63;
_.typeId$ = 36;
_.appliedImpulse = 0;
_.appliedImpulseLateral1 = 0;
_.appliedImpulseLateral2 = 0;
_.combinedFriction = 0;
_.combinedRestitution = 0;
_.distance1 = 0;
_.index0 = 0;
_.index1 = 0;
_.lateralFrictionInitialized = false;
_.lifeTime = 0;
_.partId0 = 0;
_.partId1 = 0;
_.userPersistentData = null;
function $$init_32(this$static){
  var i;
  this$static.pointCache = initDim(_3Lcom_bulletphysics_gwt_client_collision_narrowphase_ManifoldPoint_2_classLit, 135, 25, 4, 0);
  for (i = 0; i < this$static.pointCache.length; ++i)
    this$static.pointCache[i] = $ManifoldPoint(new ManifoldPoint);
}

function $PersistentManifold(this$static){
  $$init_32(this$static);
  return this$static;
}

function $addManifoldPoint(this$static, newPoint){
  var insertIndex;
  insertIndex = this$static.cachedPoints;
  if (insertIndex == 4) {
    insertIndex = $sortCachedPoints(this$static, newPoint);
    $clearUserCache(this$static.pointCache[insertIndex]);
  }
   else {
    ++this$static.cachedPoints;
  }
  $set_2(this$static.pointCache[insertIndex], newPoint);
  return insertIndex;
}

function $clearManifold(this$static){
  var i;
  for (i = 0; i < this$static.cachedPoints; ++i) {
    $clearUserCache(this$static.pointCache[i]);
  }
  this$static.cachedPoints = 0;
}

function $clearUserCache(pt){
  var oldPtr;
  oldPtr = pt.userPersistentData;
  if (oldPtr != null) {
    if (pt.userPersistentData != null && !!gContactDestroyedCallback) {
      --gContactDestroyedCallback.this$0.totalCpd;
      pt.userPersistentData = null;
    }
  }
}

function $getCacheEntry(this$static, newPoint){
  var diffA, distToManiPoint, i, mp, nearestPoint, shortestDist, size;
  shortestDist = 3.9999998989515007E-4;
  size = this$static.cachedPoints;
  nearestPoint = -1;
  diffA = $Vector3f_2(new Vector3f);
  for (i = 0; i < size; ++i) {
    mp = this$static.pointCache[i];
    $sub(diffA, mp.localPointA, newPoint.localPointA);
    distToManiPoint = diffA.x * diffA.x + diffA.y * diffA.y + diffA.z * diffA.z;
    if (distToManiPoint < shortestDist) {
      shortestDist = distToManiPoint;
      nearestPoint = i;
    }
  }
  return nearestPoint;
}

function $refreshContactPoints_0(this$static, trA, trB){
  var distance2d, i, manifoldPoint, projectedDifference, projectedPoint, tmp;
  tmp = $Vector3f_2(new Vector3f);
  for (i = this$static.cachedPoints - 1; i >= 0; --i) {
    manifoldPoint = this$static.pointCache[i];
    $set_9(manifoldPoint.positionWorldOnA, manifoldPoint.localPointA);
    $transform(trA, manifoldPoint.positionWorldOnA);
    $set_9(manifoldPoint.positionWorldOnB, manifoldPoint.localPointB);
    $transform(trB, manifoldPoint.positionWorldOnB);
    $set_9(tmp, manifoldPoint.positionWorldOnA);
    $sub_0(tmp, manifoldPoint.positionWorldOnB);
    manifoldPoint.distance1 = $dot(tmp, manifoldPoint.normalWorldOnB);
    ++manifoldPoint.lifeTime;
  }
  projectedDifference = $Vector3f_2(new Vector3f);
  projectedPoint = $Vector3f_2(new Vector3f);
  for (i = this$static.cachedPoints - 1; i >= 0; --i) {
    manifoldPoint = this$static.pointCache[i];
    if (manifoldPoint.distance1 <= 0.019999999552965164) {
      $scale(tmp, manifoldPoint.distance1, manifoldPoint.normalWorldOnB);
      $sub(projectedPoint, manifoldPoint.positionWorldOnA, tmp);
      $sub(projectedDifference, manifoldPoint.positionWorldOnB, projectedPoint);
      distance2d = projectedDifference.x * projectedDifference.x + projectedDifference.y * projectedDifference.y + projectedDifference.z * projectedDifference.z;
      distance2d > 3.9999998989515007E-4 && $removeContactPoint(this$static, i);
    }
     else {
      $removeContactPoint(this$static, i);
    }
  }
}

function $removeContactPoint(this$static, index){
  var lastUsedIndex;
  $clearUserCache(this$static.pointCache[index]);
  lastUsedIndex = this$static.cachedPoints - 1;
  if (index != lastUsedIndex) {
    $set_2(this$static.pointCache[index], this$static.pointCache[lastUsedIndex]);
    this$static.pointCache[lastUsedIndex].userPersistentData = null;
    this$static.pointCache[lastUsedIndex].appliedImpulse = 0;
    this$static.pointCache[lastUsedIndex].lateralFrictionInitialized = false;
    this$static.pointCache[lastUsedIndex].appliedImpulseLateral1 = 0;
    this$static.pointCache[lastUsedIndex].appliedImpulseLateral2 = 0;
    this$static.pointCache[lastUsedIndex].lifeTime = 0;
  }
  --this$static.cachedPoints;
}

function $replaceContactPoint(this$static, newPoint, insertIndex){
  var appliedImpulse, appliedLateralImpulse1, appliedLateralImpulse2, cache, lifeTime;
  lifeTime = this$static.pointCache[insertIndex].lifeTime;
  appliedImpulse = this$static.pointCache[insertIndex].appliedImpulse;
  appliedLateralImpulse1 = this$static.pointCache[insertIndex].appliedImpulseLateral1;
  appliedLateralImpulse2 = this$static.pointCache[insertIndex].appliedImpulseLateral2;
  cache = this$static.pointCache[insertIndex].userPersistentData;
  $set_2(this$static.pointCache[insertIndex], newPoint);
  this$static.pointCache[insertIndex].userPersistentData = cache;
  this$static.pointCache[insertIndex].appliedImpulse = appliedImpulse;
  this$static.pointCache[insertIndex].appliedImpulseLateral1 = appliedLateralImpulse1;
  this$static.pointCache[insertIndex].appliedImpulseLateral2 = appliedLateralImpulse2;
  this$static.pointCache[insertIndex].lifeTime = lifeTime;
}

function $setBodies(this$static, body0, body1){
  this$static.body0 = body0;
  this$static.body1 = body1;
}

function $sortCachedPoints(this$static, pt){
  var a0, a1, a2, a3, b0, b1, b2, b3, biggestarea, cross, i, maxPenetration, maxPenetrationIndex, maxvec, res0, res1, res2, res3, tmp;
  maxPenetrationIndex = -1;
  maxPenetration = pt.distance1;
  for (i = 0; i < 4; ++i) {
    if (this$static.pointCache[i].distance1 < maxPenetration) {
      maxPenetrationIndex = i;
      maxPenetration = this$static.pointCache[i].distance1;
    }
  }
  res0 = 0;
  res1 = 0;
  res2 = 0;
  res3 = 0;
  if (maxPenetrationIndex != 0) {
    a0 = $Vector3f_1(new Vector3f, pt.localPointA);
    $sub_0(a0, this$static.pointCache[1].localPointA);
    b0 = $Vector3f_1(new Vector3f, this$static.pointCache[3].localPointA);
    $sub_0(b0, this$static.pointCache[2].localPointA);
    cross = $Vector3f_2(new Vector3f);
    $cross(cross, a0, b0);
    res0 = cross.x * cross.x + cross.y * cross.y + cross.z * cross.z;
  }
  if (maxPenetrationIndex != 1) {
    a1 = $Vector3f_1(new Vector3f, pt.localPointA);
    $sub_0(a1, this$static.pointCache[0].localPointA);
    b1 = $Vector3f_1(new Vector3f, this$static.pointCache[3].localPointA);
    $sub_0(b1, this$static.pointCache[2].localPointA);
    cross = $Vector3f_2(new Vector3f);
    $cross(cross, a1, b1);
    res1 = cross.x * cross.x + cross.y * cross.y + cross.z * cross.z;
  }
  if (maxPenetrationIndex != 2) {
    a2 = $Vector3f_1(new Vector3f, pt.localPointA);
    $sub_0(a2, this$static.pointCache[0].localPointA);
    b2 = $Vector3f_1(new Vector3f, this$static.pointCache[3].localPointA);
    $sub_0(b2, this$static.pointCache[1].localPointA);
    cross = $Vector3f_2(new Vector3f);
    $cross(cross, a2, b2);
    res2 = cross.x * cross.x + cross.y * cross.y + cross.z * cross.z;
  }
  if (maxPenetrationIndex != 3) {
    a3 = $Vector3f_1(new Vector3f, pt.localPointA);
    $sub_0(a3, this$static.pointCache[0].localPointA);
    b3 = $Vector3f_1(new Vector3f, this$static.pointCache[2].localPointA);
    $sub_0(b3, this$static.pointCache[1].localPointA);
    cross = $Vector3f_2(new Vector3f);
    $cross(cross, a3, b3);
    res3 = cross.x * cross.x + cross.y * cross.y + cross.z * cross.z;
  }
  maxvec = $Vector4f_0(new Vector4f);
  maxvec.x = res0;
  maxvec.y = res1;
  maxvec.z = res2;
  maxvec.w = res3;
  biggestarea = (tmp = $Vector4f(new Vector4f, maxvec) , tmp.x = abs(tmp.x) , tmp.y = abs(tmp.y) , tmp.z = abs(tmp.z) , tmp.w = abs(tmp.w) , maxAxis4(tmp));
  return biggestarea;
}

function getClass_64(){
  return Lcom_bulletphysics_gwt_client_collision_narrowphase_PersistentManifold_2_classLit;
}

function PersistentManifold(){
}

_ = PersistentManifold.prototype = new Object_0;
_.getClass$ = getClass_64;
_.typeId$ = 37;
_.body0 = null;
_.body1 = null;
_.cachedPoints = 0;
_.index1a = 0;
function $PointCollector(this$static){
  this$static.normalOnBInWorld = $Vector3f_2(new Vector3f);
  this$static.pointInWorld = $Vector3f_2(new Vector3f);
  return this$static;
}

function addContactPoint_0(normalOnBInWorld, pointInWorld, depth){
  if (depth < this.distance) {
    this.hasResult = true;
    $set_9(this.normalOnBInWorld, normalOnBInWorld);
    $set_9(this.pointInWorld, pointInWorld);
    this.distance = depth;
  }
}

function getClass_65(){
  return Lcom_bulletphysics_gwt_client_collision_narrowphase_PointCollector_2_classLit;
}

function PointCollector(){
}

_ = PointCollector.prototype = new Object_0;
_.addContactPoint = addContactPoint_0;
_.getClass$ = getClass_65;
_.typeId$ = 0;
_.distance = 1.0000000150474662E30;
_.hasResult = false;
function $$init_34(this$static){
  var i;
  this$static.subsimplexResultsPool = get_1(Lcom_bulletphysics_gwt_client_collision_narrowphase_VoronoiSimplexSolver$SubSimplexClosestResult_2_classLit, ($clinit_125() , subSimplexClosestResultFactory));
  this$static.simplexVectorW = initDim(_3Lcom_bulletphysics_gwt_client_vecmath_Vector3f_2_classLit, 143, 53, 5, 0);
  this$static.simplexPointsP = initDim(_3Lcom_bulletphysics_gwt_client_vecmath_Vector3f_2_classLit, 143, 53, 5, 0);
  this$static.simplexPointsQ = initDim(_3Lcom_bulletphysics_gwt_client_vecmath_Vector3f_2_classLit, 143, 53, 5, 0);
  this$static.cachedP1 = $Vector3f_2(new Vector3f);
  this$static.cachedP2 = $Vector3f_2(new Vector3f);
  this$static.cachedV = $Vector3f_2(new Vector3f);
  this$static.lastW = $Vector3f_2(new Vector3f);
  this$static.cachedBC = $VoronoiSimplexSolver$SubSimplexClosestResult(new VoronoiSimplexSolver$SubSimplexClosestResult);
  for (i = 0; i < 5; ++i) {
    this$static.simplexVectorW[i] = $Vector3f_2(new Vector3f);
    this$static.simplexPointsP[i] = $Vector3f_2(new Vector3f);
    this$static.simplexPointsQ[i] = $Vector3f_2(new Vector3f);
  }
}

function $VoronoiSimplexSolver(this$static){
  $$init_34(this$static);
  return this$static;
}

function $addVertex(this$static, w, p, q){
  $set_9(this$static.lastW, w);
  this$static.needsUpdate = true;
  $set_9(this$static.simplexVectorW[this$static.numVertices], w);
  $set_9(this$static.simplexPointsP[this$static.numVertices], p);
  $set_9(this$static.simplexPointsQ[this$static.numVertices], q);
  ++this$static.numVertices;
}

function $backup_closest(this$static, v){
  $set_9(v, this$static.cachedV);
}

function $closest(this$static, v){
  var succes;
  succes = $updateClosestVectorAndPoints(this$static);
  $set_9(v, this$static.cachedV);
  return succes;
}

--></script>
<script><!--
function $closestPtPointTetrahedron(this$static, p, a, b, c, d, finalResult){
  var bestSqDist, pointOutsideABC, pointOutsideACD, pointOutsideADB, pointOutsideBDC, q, sqDist, tempResult, tmp;
  tempResult = dynamicCast($get_1(this$static.subsimplexResultsPool), 34);
  $reset_1(tempResult);
  try {
    tmp = $Vector3f_2(new Vector3f);
    q = $Vector3f_2(new Vector3f);
    $set_9(finalResult.closestPointOnSimplex, p);
    $reset_2(finalResult.usedVertices);
    finalResult.usedVertices.usedVertexA = true;
    finalResult.usedVertices.usedVertexB = true;
    finalResult.usedVertices.usedVertexC = true;
    finalResult.usedVertices.usedVertexD = true;
    pointOutsideABC = pointOutsideOfPlane(p, a, b, c, d);
    pointOutsideACD = pointOutsideOfPlane(p, a, c, d, b);
    pointOutsideADB = pointOutsideOfPlane(p, a, d, b, c);
    pointOutsideBDC = pointOutsideOfPlane(p, b, d, c, a);
    if (pointOutsideABC < 0 || pointOutsideACD < 0 || pointOutsideADB < 0 || pointOutsideBDC < 0) {
      finalResult.degenerate = true;
      return false;
    }
    if (pointOutsideABC == 0 && pointOutsideACD == 0 && pointOutsideADB == 0 && pointOutsideBDC == 0) {
      return false;
    }
    bestSqDist = 3.4028234663852886E38;
    if (pointOutsideABC != 0) {
      $closestPtPointTriangle(p, a, b, c, tempResult);
      $set_9(q, tempResult.closestPointOnSimplex);
      $sub(tmp, q, p);
      sqDist = tmp.x * tmp.x + tmp.y * tmp.y + tmp.z * tmp.z;
      if (sqDist < bestSqDist) {
        bestSqDist = sqDist;
        $set_9(finalResult.closestPointOnSimplex, q);
        $reset_2(finalResult.usedVertices);
        finalResult.usedVertices.usedVertexA = tempResult.usedVertices.usedVertexA;
        finalResult.usedVertices.usedVertexB = tempResult.usedVertices.usedVertexB;
        finalResult.usedVertices.usedVertexC = tempResult.usedVertices.usedVertexC;
        $setBarycentricCoordinates(finalResult, tempResult.barycentricCoords[0], tempResult.barycentricCoords[1], tempResult.barycentricCoords[2], 0);
      }
    }
    if (pointOutsideACD != 0) {
      $closestPtPointTriangle(p, a, c, d, tempResult);
      $set_9(q, tempResult.closestPointOnSimplex);
      $sub(tmp, q, p);
      sqDist = tmp.x * tmp.x + tmp.y * tmp.y + tmp.z * tmp.z;
      if (sqDist < bestSqDist) {
        bestSqDist = sqDist;
        $set_9(finalResult.closestPointOnSimplex, q);
        $reset_2(finalResult.usedVertices);
        finalResult.usedVertices.usedVertexA = tempResult.usedVertices.usedVertexA;
        finalResult.usedVertices.usedVertexC = tempResult.usedVertices.usedVertexB;
        finalResult.usedVertices.usedVertexD = tempResult.usedVertices.usedVertexC;
        $setBarycentricCoordinates(finalResult, tempResult.barycentricCoords[0], 0, tempResult.barycentricCoords[1], tempResult.barycentricCoords[2]);
      }
    }
    if (pointOutsideADB != 0) {
      $closestPtPointTriangle(p, a, d, b, tempResult);
      $set_9(q, tempResult.closestPointOnSimplex);
      $sub(tmp, q, p);
      sqDist = tmp.x * tmp.x + tmp.y * tmp.y + tmp.z * tmp.z;
      if (sqDist < bestSqDist) {
        bestSqDist = sqDist;
        $set_9(finalResult.closestPointOnSimplex, q);
        $reset_2(finalResult.usedVertices);
        finalResult.usedVertices.usedVertexA = tempResult.usedVertices.usedVertexA;
        finalResult.usedVertices.usedVertexB = tempResult.usedVertices.usedVertexC;
        finalResult.usedVertices.usedVertexD = tempResult.usedVertices.usedVertexB;
        $setBarycentricCoordinates(finalResult, tempResult.barycentricCoords[0], tempResult.barycentricCoords[2], 0, tempResult.barycentricCoords[1]);
      }
    }
    if (pointOutsideBDC != 0) {
      $closestPtPointTriangle(p, b, d, c, tempResult);
      $set_9(q, tempResult.closestPointOnSimplex);
      $sub(tmp, q, p);
      sqDist = tmp.x * tmp.x + tmp.y * tmp.y + tmp.z * tmp.z;
      if (sqDist < bestSqDist) {
        bestSqDist = sqDist;
        $set_9(finalResult.closestPointOnSimplex, q);
        $reset_2(finalResult.usedVertices);
        finalResult.usedVertices.usedVertexB = tempResult.usedVertices.usedVertexA;
        finalResult.usedVertices.usedVertexC = tempResult.usedVertices.usedVertexC;
        finalResult.usedVertices.usedVertexD = tempResult.usedVertices.usedVertexB;
        $setBarycentricCoordinates(finalResult, 0, tempResult.barycentricCoords[0], tempResult.barycentricCoords[2], tempResult.barycentricCoords[1]);
      }
    }
    if (finalResult.usedVertices.usedVertexA && finalResult.usedVertices.usedVertexB && finalResult.usedVertices.usedVertexC && finalResult.usedVertices.usedVertexD) {
      return true;
    }
    return true;
  }
   finally {
    $add_7(this$static.subsimplexResultsPool.list, tempResult);
  }
}

function $closestPtPointTriangle(p, a, b, c, result){
  var ab, ac, ap, bp, cp, d1, d2, d3, d4, d5, d6, denom, tmp, tmp1, tmp2, v, va, vb, vc, w;
  $reset_2(result.usedVertices);
  ab = $Vector3f_2(new Vector3f);
  $sub(ab, b, a);
  ac = $Vector3f_2(new Vector3f);
  $sub(ac, c, a);
  ap = $Vector3f_2(new Vector3f);
  $sub(ap, p, a);
  d1 = ab.x * ap.x + ab.y * ap.y + ab.z * ap.z;
  d2 = ac.x * ap.x + ac.y * ap.y + ac.z * ap.z;
  if (d1 <= 0 && d2 <= 0) {
    $set_9(result.closestPointOnSimplex, a);
    result.usedVertices.usedVertexA = true;
    result.barycentricCoords[0] = 1;
    result.barycentricCoords[1] = 0;
    result.barycentricCoords[2] = 0;
    result.barycentricCoords[3] = 0;
    return true;
  }
  bp = $Vector3f_2(new Vector3f);
  $sub(bp, p, b);
  d3 = ab.x * bp.x + ab.y * bp.y + ab.z * bp.z;
  d4 = ac.x * bp.x + ac.y * bp.y + ac.z * bp.z;
  if (d3 >= 0 && d4 <= d3) {
    $set_9(result.closestPointOnSimplex, b);
    result.usedVertices.usedVertexB = true;
    result.barycentricCoords[0] = 0;
    result.barycentricCoords[1] = 1;
    result.barycentricCoords[2] = 0;
    result.barycentricCoords[3] = 0;
    return true;
  }
  vc = d1 * d4 - d3 * d2;
  if (vc <= 0 && d1 >= 0 && d3 <= 0) {
    v = d1 / (d1 - d3);
    $scaleAdd(result.closestPointOnSimplex, v, ab, a);
    result.usedVertices.usedVertexA = true;
    result.usedVertices.usedVertexB = true;
    result.barycentricCoords[0] = 1 - v;
    result.barycentricCoords[1] = v;
    result.barycentricCoords[2] = 0;
    result.barycentricCoords[3] = 0;
    return true;
  }
  cp = $Vector3f_2(new Vector3f);
  $sub(cp, p, c);
  d5 = ab.x * cp.x + ab.y * cp.y + ab.z * cp.z;
  d6 = ac.x * cp.x + ac.y * cp.y + ac.z * cp.z;
  if (d6 >= 0 && d5 <= d6) {
    $set_9(result.closestPointOnSimplex, c);
    result.usedVertices.usedVertexC = true;
    result.barycentricCoords[0] = 0;
    result.barycentricCoords[1] = 0;
    result.barycentricCoords[2] = 1;
    result.barycentricCoords[3] = 0;
    return true;
  }
  vb = d5 * d2 - d1 * d6;
  if (vb <= 0 && d2 >= 0 && d6 <= 0) {
    w = d2 / (d2 - d6);
    $scaleAdd(result.closestPointOnSimplex, w, ac, a);
    result.usedVertices.usedVertexA = true;
    result.usedVertices.usedVertexC = true;
    result.barycentricCoords[0] = 1 - w;
    result.barycentricCoords[1] = 0;
    result.barycentricCoords[2] = w;
    result.barycentricCoords[3] = 0;
    return true;
  }
  va = d3 * d6 - d5 * d4;
  if (va <= 0 && d4 - d3 >= 0 && d5 - d6 >= 0) {
    w = (d4 - d3) / (d4 - d3 + (d5 - d6));
    tmp = $Vector3f_2(new Vector3f);
    $sub(tmp, c, b);
    $scaleAdd(result.closestPointOnSimplex, w, tmp, b);
    result.usedVertices.usedVertexB = true;
    result.usedVertices.usedVertexC = true;
    result.barycentricCoords[0] = 0;
    result.barycentricCoords[1] = 1 - w;
    result.barycentricCoords[2] = w;
    result.barycentricCoords[3] = 0;
    return true;
  }
  denom = 1 / (va + vb + vc);
  v = vb * denom;
  w = vc * denom;
  tmp1 = $Vector3f_2(new Vector3f);
  tmp2 = $Vector3f_2(new Vector3f);
  tmp1.x = v * ab.x;
  tmp1.y = v * ab.y;
  tmp1.z = v * ab.z;
  tmp2.x = w * ac.x;
  tmp2.y = w * ac.y;
  tmp2.z = w * ac.z;
  add(result.closestPointOnSimplex, a, tmp1, tmp2);
  result.usedVertices.usedVertexA = true;
  result.usedVertices.usedVertexB = true;
  result.usedVertices.usedVertexC = true;
  result.barycentricCoords[0] = 1 - v - w;
  result.barycentricCoords[1] = v;
  result.barycentricCoords[2] = w;
  result.barycentricCoords[3] = 0;
  return true;
}

function $compute_points(this$static, p1, p2){
  $updateClosestVectorAndPoints(this$static);
  $set_9(p1, this$static.cachedP1);
  $set_9(p2, this$static.cachedP2);
}

function $inSimplex(this$static, w){
  var found, i, numverts;
  found = false;
  numverts = this$static.numVertices;
  for (i = 0; i < numverts; ++i) {
    $equals_2(this$static.simplexVectorW[i], w) && (found = true);
  }
  if ($equals_2(w, this$static.lastW)) {
    return true;
  }
  return found;
}

function $reduceVertices(this$static, usedVerts){
  this$static.numVertices >= 4 && !usedVerts.usedVertexD && $removeVertex(this$static, 3);
  this$static.numVertices >= 3 && !usedVerts.usedVertexC && $removeVertex(this$static, 2);
  this$static.numVertices >= 2 && !usedVerts.usedVertexB && $removeVertex(this$static, 1);
  this$static.numVertices >= 1 && !usedVerts.usedVertexA && $removeVertex(this$static, 0);
}

function $removeVertex(this$static, index){
  --this$static.numVertices;
  $set_9(this$static.simplexVectorW[index], this$static.simplexVectorW[this$static.numVertices]);
  $set_9(this$static.simplexPointsP[index], this$static.simplexPointsP[this$static.numVertices]);
  $set_9(this$static.simplexPointsQ[index], this$static.simplexPointsQ[this$static.numVertices]);
}

function $reset_0(this$static){
  this$static.cachedValidClosest = false;
  this$static.numVertices = 0;
  this$static.needsUpdate = true;
  $set_8(this$static.lastW, 1.0000000150474662E30, 1.0000000150474662E30, 1.0000000150474662E30);
  $reset_1(this$static.cachedBC);
}

function $updateClosestVectorAndPoints(this$static){
  var a, b, c, d, diff, dotVV, from, hasSeperation, nearest, p, t, tmp, tmp1, tmp2, tmp3, tmp4, to, v;
  if (this$static.needsUpdate) {
    $reset_1(this$static.cachedBC);
    this$static.needsUpdate = false;
    switch (this$static.numVertices) {
      case 0:
        this$static.cachedValidClosest = false;
        break;
      case 1:
        {
          $set_9(this$static.cachedP1, this$static.simplexPointsP[0]);
          $set_9(this$static.cachedP2, this$static.simplexPointsQ[0]);
          $sub(this$static.cachedV, this$static.cachedP1, this$static.cachedP2);
          $reset_1(this$static.cachedBC);
          $setBarycentricCoordinates(this$static.cachedBC, 1, 0, 0, 0);
          this$static.cachedValidClosest = $isValid(this$static.cachedBC);
          break;
        }

      case 2:
        {
          tmp = $Vector3f_2(new Vector3f);
          from = this$static.simplexVectorW[0];
          to = this$static.simplexVectorW[1];
          nearest = $Vector3f_2(new Vector3f);
          p = $Vector3f_2(new Vector3f);
          p.x = 0;
          p.y = 0;
          p.z = 0;
          diff = $Vector3f_2(new Vector3f);
          $sub(diff, p, from);
          v = $Vector3f_2(new Vector3f);
          $sub(v, to, from);
          t = v.x * diff.x + v.y * diff.y + v.z * diff.z;
          if (t > 0) {
            dotVV = v.x * v.x + v.y * v.y + v.z * v.z;
            if (t < dotVV) {
              t /= dotVV;
              tmp.x = t * v.x;
              tmp.y = t * v.y;
              tmp.z = t * v.z;
              diff.x -= tmp.x;
              diff.y -= tmp.y;
              diff.z -= tmp.z;
              this$static.cachedBC.usedVertices.usedVertexA = true;
              this$static.cachedBC.usedVertices.usedVertexB = true;
            }
             else {
              t = 1;
              diff.x -= v.x;
              diff.y -= v.y;
              diff.z -= v.z;
              this$static.cachedBC.usedVertices.usedVertexB = true;
            }
          }
           else {
            t = 0;
            this$static.cachedBC.usedVertices.usedVertexA = true;
          }
          $setBarycentricCoordinates(this$static.cachedBC, 1 - t, t, 0, 0);
          tmp.x = t * v.x;
          tmp.y = t * v.y;
          tmp.z = t * v.z;
          $add_1(nearest, from, tmp);
          $sub(tmp, this$static.simplexPointsP[1], this$static.simplexPointsP[0]);
          tmp.x *= t;
          tmp.y *= t;
          tmp.z *= t;
          $add_1(this$static.cachedP1, this$static.simplexPointsP[0], tmp);
          $sub(tmp, this$static.simplexPointsQ[1], this$static.simplexPointsQ[0]);
          tmp.x *= t;
          tmp.y *= t;
          tmp.z *= t;
          $add_1(this$static.cachedP2, this$static.simplexPointsQ[0], tmp);
          $sub(this$static.cachedV, this$static.cachedP1, this$static.cachedP2);
          $reduceVertices(this$static, this$static.cachedBC.usedVertices);
          this$static.cachedValidClosest = $isValid(this$static.cachedBC);
          break;
        }

      case 3:
        {
          tmp1 = $Vector3f_2(new Vector3f);
          tmp2 = $Vector3f_2(new Vector3f);
          tmp3 = $Vector3f_2(new Vector3f);
          p = $Vector3f_2(new Vector3f);
          p.x = 0;
          p.y = 0;
          p.z = 0;
          a = this$static.simplexVectorW[0];
          b = this$static.simplexVectorW[1];
          c = this$static.simplexVectorW[2];
          $closestPtPointTriangle(p, a, b, c, this$static.cachedBC);
          $scale(tmp1, this$static.cachedBC.barycentricCoords[0], this$static.simplexPointsP[0]);
          $scale(tmp2, this$static.cachedBC.barycentricCoords[1], this$static.simplexPointsP[1]);
          $scale(tmp3, this$static.cachedBC.barycentricCoords[2], this$static.simplexPointsP[2]);
          add(this$static.cachedP1, tmp1, tmp2, tmp3);
          $scale(tmp1, this$static.cachedBC.barycentricCoords[0], this$static.simplexPointsQ[0]);
          $scale(tmp2, this$static.cachedBC.barycentricCoords[1], this$static.simplexPointsQ[1]);
          $scale(tmp3, this$static.cachedBC.barycentricCoords[2], this$static.simplexPointsQ[2]);
          add(this$static.cachedP2, tmp1, tmp2, tmp3);
          $sub(this$static.cachedV, this$static.cachedP1, this$static.cachedP2);
          $reduceVertices(this$static, this$static.cachedBC.usedVertices);
          this$static.cachedValidClosest = $isValid(this$static.cachedBC);
          break;
        }

      case 4:
        {
          tmp1 = $Vector3f_2(new Vector3f);
          tmp2 = $Vector3f_2(new Vector3f);
          tmp3 = $Vector3f_2(new Vector3f);
          tmp4 = $Vector3f_2(new Vector3f);
          p = $Vector3f_2(new Vector3f);
          p.x = 0;
          p.y = 0;
          p.z = 0;
          a = this$static.simplexVectorW[0];
          b = this$static.simplexVectorW[1];
          c = this$static.simplexVectorW[2];
          d = this$static.simplexVectorW[3];
          hasSeperation = $closestPtPointTetrahedron(this$static, p, a, b, c, d, this$static.cachedBC);
          if (hasSeperation) {
            $scale(tmp1, this$static.cachedBC.barycentricCoords[0], this$static.simplexPointsP[0]);
            $scale(tmp2, this$static.cachedBC.barycentricCoords[1], this$static.simplexPointsP[1]);
            $scale(tmp3, this$static.cachedBC.barycentricCoords[2], this$static.simplexPointsP[2]);
            $scale(tmp4, this$static.cachedBC.barycentricCoords[3], this$static.simplexPointsP[3]);
            add_0(this$static.cachedP1, tmp1, tmp2, tmp3, tmp4);
            $scale(tmp1, this$static.cachedBC.barycentricCoords[0], this$static.simplexPointsQ[0]);
            $scale(tmp2, this$static.cachedBC.barycentricCoords[1], this$static.simplexPointsQ[1]);
            $scale(tmp3, this$static.cachedBC.barycentricCoords[2], this$static.simplexPointsQ[2]);
            $scale(tmp4, this$static.cachedBC.barycentricCoords[3], this$static.simplexPointsQ[3]);
            add_0(this$static.cachedP2, tmp1, tmp2, tmp3, tmp4);
            $sub(this$static.cachedV, this$static.cachedP1, this$static.cachedP2);
            $reduceVertices(this$static, this$static.cachedBC.usedVertices);
          }
           else {
            if (this$static.cachedBC.degenerate) {
              this$static.cachedValidClosest = false;
            }
             else {
              this$static.cachedValidClosest = true;
              $set_8(this$static.cachedV, 0, 0, 0);
            }
            break;
          }
          this$static.cachedValidClosest = $isValid(this$static.cachedBC);
          break;
        }

      default:{
          this$static.cachedValidClosest = false;
        }

    }
  }
  return this$static.cachedValidClosest;
}

function getClass_66(){
  return Lcom_bulletphysics_gwt_client_collision_narrowphase_VoronoiSimplexSolver_2_classLit;
}

function pointOutsideOfPlane(p, a, b, c, d){
  var normal, signd, signp, tmp;
  tmp = $Vector3f_2(new Vector3f);
  normal = $Vector3f_2(new Vector3f);
  $sub(normal, b, a);
  $sub(tmp, c, a);
  $cross(normal, normal, tmp);
  $sub(tmp, p, a);
  signp = tmp.x * normal.x + tmp.y * normal.y + tmp.z * normal.z;
  $sub(tmp, d, a);
  signd = tmp.x * normal.x + tmp.y * normal.y + tmp.z * normal.z;
  if (signd * signd < 9.99999905104687E-9) {
    return -1;
  }
  return signp * signd < 0?1:0;
}

function VoronoiSimplexSolver(){
}

_ = VoronoiSimplexSolver.prototype = new Object_0;
_.getClass$ = getClass_66;
_.typeId$ = 0;
_.cachedValidClosest = false;
_.needsUpdate = false;
_.numVertices = 0;
function $VoronoiSimplexSolver$SubSimplexClosestResult(this$static){
  this$static.closestPointOnSimplex = $Vector3f_2(new Vector3f);
  this$static.usedVertices = new VoronoiSimplexSolver$UsageBitfield;
  this$static.barycentricCoords = initDim(_3F_classLit, 149, -1, 4, 1);
  return this$static;
}

function $isValid(this$static){
  var valid;
  valid = this$static.barycentricCoords[0] >= 0 && this$static.barycentricCoords[1] >= 0 && this$static.barycentricCoords[2] >= 0 && this$static.barycentricCoords[3] >= 0;
  return valid;
}

function $reset_1(this$static){
  this$static.degenerate = false;
  this$static.barycentricCoords[0] = 0;
  this$static.barycentricCoords[1] = 0;
  this$static.barycentricCoords[2] = 0;
  this$static.barycentricCoords[3] = 0;
  $reset_2(this$static.usedVertices);
}

function $setBarycentricCoordinates(this$static, a, b, c, d){
  this$static.barycentricCoords[0] = a;
  this$static.barycentricCoords[1] = b;
  this$static.barycentricCoords[2] = c;
  this$static.barycentricCoords[3] = d;
}

function getClass_67(){
  return Lcom_bulletphysics_gwt_client_collision_narrowphase_VoronoiSimplexSolver$SubSimplexClosestResult_2_classLit;
}

function VoronoiSimplexSolver$SubSimplexClosestResult(){
}

_ = VoronoiSimplexSolver$SubSimplexClosestResult.prototype = new Object_0;
_.getClass$ = getClass_67;
_.typeId$ = 38;
_.degenerate = false;
function $reset_2(this$static){
  this$static.usedVertexA = false;
  this$static.usedVertexB = false;
  this$static.usedVertexC = false;
  this$static.usedVertexD = false;
}

function getClass_68(){
  return Lcom_bulletphysics_gwt_client_collision_narrowphase_VoronoiSimplexSolver$UsageBitfield_2_classLit;
}

function VoronoiSimplexSolver$UsageBitfield(){
}

_ = VoronoiSimplexSolver$UsageBitfield.prototype = new Object_0;
_.getClass$ = getClass_68;
_.typeId$ = 0;
_.usedVertexA = false;
_.usedVertexB = false;
_.usedVertexC = false;
_.usedVertexD = false;
function getClass_69(){
  return Lcom_bulletphysics_gwt_client_collision_shapes_CollisionShape_2_classLit;
}

function CollisionShape(){
}

_ = CollisionShape.prototype = new Object_0;
_.getClass$ = getClass_69;
_.typeId$ = 39;
function getClass_70(){
  return Lcom_bulletphysics_gwt_client_collision_shapes_ConvexShape_2_classLit;
}

function ConvexShape(){
}

_ = ConvexShape.prototype = new CollisionShape;
_.getClass$ = getClass_70;
_.typeId$ = 40;
function $$init_36(this$static){
  this$static.localScaling = $Vector3f(new Vector3f, 1, 1, 1);
  this$static.implicitShapeDimensions = $Vector3f_2(new Vector3f);
}

function $getAabbSlow(this$static, trans, minAabb, maxAabb){
  var i, margin, tmp1, tmp2, vec;
  margin = this$static.getMargin();
  vec = $Vector3f_2(new Vector3f);
  tmp1 = $Vector3f_2(new Vector3f);
  tmp2 = $Vector3f_2(new Vector3f);
  for (i = 0; i < 3; ++i) {
    vec.x = 0;
    vec.y = 0;
    vec.z = 0;
    setCoord(vec, i, 1);
    transposeTransform(tmp1, vec, trans.basis);
    this$static.localGetSupportingVertex(tmp1, tmp2);
    $transform_0(trans.basis, tmp2);
    $add_2(tmp2, trans.origin);
    setCoord(maxAabb, i, getCoord(tmp2, i) + margin);
    setCoord(vec, i, -1);
    transposeTransform(tmp1, vec, trans.basis);
    this$static.localGetSupportingVertex(tmp1, tmp2);
    $transform_0(trans.basis, tmp2);
    $add_2(tmp2, trans.origin);
    setCoord(minAabb, i, getCoord(tmp2, i) - margin);
  }
}

function getAabb(t, aabbMin, aabbMax){
  $getAabbSlow(this, t, aabbMin, aabbMax);
}

function getClass_71(){
  return Lcom_bulletphysics_gwt_client_collision_shapes_ConvexInternalShape_2_classLit;
}

function getMargin(){
  return 0.03999999910593033;
}

function localGetSupportingVertex(vec, out){
  var supVertex, vecnorm;
  supVertex = this.localGetSupportingVertexWithoutMargin(vec, out);
  if (this.getMargin() != 0) {
    vecnorm = $Vector3f_1(new Vector3f, vec);
    vecnorm.x * vecnorm.x + vecnorm.y * vecnorm.y + vecnorm.z * vecnorm.z < 1.4210854715202004E-14 && (vecnorm.x = -1 , vecnorm.y = -1 , vecnorm.z = -1 , undefined);
    $normalize_1(vecnorm);
    $scaleAdd(supVertex, this.getMargin(), vecnorm, supVertex);
  }
  return out;
}

function ConvexInternalShape(){
}

_ = ConvexInternalShape.prototype = new ConvexShape;
_.getAabb = getAabb;
_.getClass$ = getClass_71;
_.getMargin = getMargin;
_.localGetSupportingVertex = localGetSupportingVertex;
_.typeId$ = 41;
function $$init_37(this$static){
  this$static.localAabbMin = $Vector3f(new Vector3f, 1, 1, 1);
  this$static.localAabbMax = $Vector3f(new Vector3f, -1, -1, -1);
}

function calculateLocalInertia(mass, inertia){
  var aabbMax, aabbMin, halfExtents, ident, lx, ly, lz, scaledmass, x2, y2, z2;
  ident = $Transform(new Transform);
  $setIdentity_0(ident.basis);
  $set_8(ident.origin, 0, 0, 0);
  aabbMin = $Vector3f_2(new Vector3f);
  aabbMax = $Vector3f_2(new Vector3f);
  this.getAabb(ident, aabbMin, aabbMax);
  halfExtents = $Vector3f_2(new Vector3f);
  $sub(halfExtents, aabbMax, aabbMin);
  halfExtents.x *= 0.5;
  halfExtents.y *= 0.5;
  halfExtents.z *= 0.5;
  lx = 2 * (halfExtents.x + 0.03999999910593033);
  ly = 2 * (halfExtents.y + 0.03999999910593033);
  lz = 2 * (halfExtents.z + 0.03999999910593033);
  x2 = lx * lx;
  y2 = ly * ly;
  z2 = lz * lz;
  scaledmass = mass * 0.0833333283662796;
  inertia.x = y2 + z2;
  inertia.y = x2 + z2;
  inertia.z = x2 + y2;
  inertia.x *= scaledmass;
  inertia.y *= scaledmass;
  inertia.z *= scaledmass;
}

function getAabb_0(trans, aabbMin, aabbMax){
  var abs_b, center, extent, localCenter, localHalfExtents, tmp;
  localHalfExtents = $Vector3f_2(new Vector3f);
  $sub(localHalfExtents, this.localAabbMax, this.localAabbMin);
  localHalfExtents.x *= 0.5;
  localHalfExtents.y *= 0.5;
  localHalfExtents.z *= 0.5;
  localCenter = $Vector3f_2(new Vector3f);
  $add_1(localCenter, this.localAabbMax, this.localAabbMin);
  localCenter.x *= 0.5;
  localCenter.y *= 0.5;
  localCenter.z *= 0.5;
  abs_b = $Matrix3f(new Matrix3f, trans.basis);
  absolute(abs_b);
  center = $Vector3f_1(new Vector3f, localCenter);
  $transform_0(trans.basis, center);
  $add_2(center, trans.origin);
  extent = $Vector3f_2(new Vector3f);
  tmp = $Vector3f_2(new Vector3f);
  $getRow(abs_b, 0, tmp);
  extent.x = tmp.x * localHalfExtents.x + tmp.y * localHalfExtents.y + tmp.z * localHalfExtents.z;
  $getRow(abs_b, 1, tmp);
  extent.y = tmp.x * localHalfExtents.x + tmp.y * localHalfExtents.y + tmp.z * localHalfExtents.z;
  $getRow(abs_b, 2, tmp);
  extent.z = tmp.x * localHalfExtents.x + tmp.y * localHalfExtents.y + tmp.z * localHalfExtents.z;
  extent.x += 0.03999999910593033;
  extent.y += 0.03999999910593033;
  extent.z += 0.03999999910593033;
  $sub(aabbMin, center, extent);
  $add_1(aabbMax, center, extent);
}

function getClass_72(){
  return Lcom_bulletphysics_gwt_client_collision_shapes_PolyhedralConvexShape_2_classLit;
}

function localGetSupportingVertexWithoutMargin(vec0, out){
  var i, lenSqr, maxDot, newDot, rlen, supVec, vec, vtx;
  supVec = out;
  supVec.x = 0;
  supVec.y = 0;
  supVec.z = 0;
  maxDot = -1.0000000150474662E30;
  vec = $Vector3f_1(new Vector3f, vec0);
  lenSqr = vec.x * vec.x + vec.y * vec.y + vec.z * vec.z;
  if (lenSqr < 9.999999747378752E-5) {
    vec.x = 1;
    vec.y = 0;
    vec.z = 0;
  }
   else {
    rlen = 1 / Math.sqrt(lenSqr);
    vec.x *= rlen;
    vec.y *= rlen;
    vec.z *= rlen;
  }
  vtx = $Vector3f_2(new Vector3f);
  for (i = 0; i < this.getNumVertices(); ++i) {
    this.getVertex(i, vtx);
    newDot = vec.x * vtx.x + vec.y * vtx.y + vec.z * vtx.z;
    if (newDot > maxDot) {
      maxDot = newDot;
      supVec = vtx;
    }
  }
  return out;
}

function PolyhedralConvexShape(){
}

_ = PolyhedralConvexShape.prototype = new ConvexInternalShape;
_.calculateLocalInertia = calculateLocalInertia;
_.getAabb = getAabb_0;
_.getClass$ = getClass_72;
_.localGetSupportingVertexWithoutMargin = localGetSupportingVertexWithoutMargin;
_.typeId$ = 42;
function $BoxShape(this$static, boxHalfExtents){
  var margin;
  $$init_36(this$static);
  $$init_37(this$static);
  margin = $Vector3f(new Vector3f, 0.03999999910593033, 0.03999999910593033, 0.03999999910593033);
  mul(this$static.implicitShapeDimensions, boxHalfExtents, this$static.localScaling);
  $sub_0(this$static.implicitShapeDimensions, margin);
  return this$static;
}

function $getHalfExtentsWithMargin(this$static, out){
  var halfExtents, margin;
  halfExtents = ($set_9(out, this$static.implicitShapeDimensions) , out);
  margin = $Vector3f_2(new Vector3f);
  margin.x = 0.03999999910593033;
  margin.y = 0.03999999910593033;
  margin.z = 0.03999999910593033;
  halfExtents.x += margin.x;
  halfExtents.y += margin.y;
  halfExtents.z += margin.z;
  return out;
}

function $getHalfExtentsWithoutMargin(this$static, out){
  $set_9(out, this$static.implicitShapeDimensions);
  return out;
}

function calculateLocalInertia_0(mass, inertia){
  var halfExtents, lx, ly, lz;
  halfExtents = $getHalfExtentsWithMargin(this, $Vector3f_2(new Vector3f));
  lx = 2 * halfExtents.x;
  ly = 2 * halfExtents.y;
  lz = 2 * halfExtents.z;
  inertia.x = mass / 12 * (ly * ly + lz * lz);
  inertia.y = mass / 12 * (lx * lx + lz * lz);
  inertia.z = mass / 12 * (lx * lx + ly * ly);
}

function getAabb_1(t, aabbMin, aabbMax){
  var abs_b, center, extent, halfExtents, margin, tmp;
  halfExtents = $getHalfExtentsWithoutMargin(this, $Vector3f_2(new Vector3f));
  abs_b = $Matrix3f(new Matrix3f, t.basis);
  absolute(abs_b);
  tmp = $Vector3f_2(new Vector3f);
  center = $Vector3f_1(new Vector3f, t.origin);
  extent = $Vector3f_2(new Vector3f);
  $getRow(abs_b, 0, tmp);
  extent.x = tmp.x * halfExtents.x + tmp.y * halfExtents.y + tmp.z * halfExtents.z;
  $getRow(abs_b, 1, tmp);
  extent.y = tmp.x * halfExtents.x + tmp.y * halfExtents.y + tmp.z * halfExtents.z;
  $getRow(abs_b, 2, tmp);
  extent.z = tmp.x * halfExtents.x + tmp.y * halfExtents.y + tmp.z * halfExtents.z;
  margin = $Vector3f_2(new Vector3f);
  margin.x = 0.03999999910593033;
  margin.y = 0.03999999910593033;
  margin.z = 0.03999999910593033;
  extent.x += margin.x;
  extent.y += margin.y;
  extent.z += margin.z;
  $sub(aabbMin, center, extent);
  $add_1(aabbMax, center, extent);
}

function getClass_73(){
  return Lcom_bulletphysics_gwt_client_collision_shapes_BoxShape_2_classLit;
}

function getNumVertices(){
  return 8;
}

function getShapeType(){
  return $clinit_12() , BOX_SHAPE_PROXYTYPE;
}

function getVertex(i, vtx){
  var halfExtents;
  halfExtents = $getHalfExtentsWithoutMargin(this, $Vector3f_2(new Vector3f));
  $set_8(vtx, halfExtents.x * (1 - (i & 1)) - halfExtents.x * (i & 1), halfExtents.y * (1 - ((i & 2) >> 1)) - halfExtents.y * ((i & 2) >> 1), halfExtents.z * (1 - ((i & 4) >> 2)) - halfExtents.z * ((i & 4) >> 2));
}

function localGetSupportingVertex_0(vec, out){
  var halfExtents;
  halfExtents = ($set_9(out, this.implicitShapeDimensions) , out);
  halfExtents.x += 0.03999999910593033;
  halfExtents.y += 0.03999999910593033;
  halfExtents.z += 0.03999999910593033;
  $set_8(out, fsel(vec.x, halfExtents.x, -halfExtents.x), fsel(vec.y, halfExtents.y, -halfExtents.y), fsel(vec.z, halfExtents.z, -halfExtents.z));
  return out;
}

function localGetSupportingVertexWithoutMargin_0(vec, out){
  var halfExtents;
  halfExtents = ($set_9(out, this.implicitShapeDimensions) , out);
  $set_8(out, fsel(vec.x, halfExtents.x, -halfExtents.x), fsel(vec.y, halfExtents.y, -halfExtents.y), fsel(vec.z, halfExtents.z, -halfExtents.z));
  return out;
}

function BoxShape(){
}

_ = BoxShape.prototype = new PolyhedralConvexShape;
_.calculateLocalInertia = calculateLocalInertia_0;
_.getAabb = getAabb_1;
_.getClass$ = getClass_73;
_.getNumVertices = getNumVertices;
_.getShapeType = getShapeType;
_.getVertex = getVertex;
_.localGetSupportingVertex = localGetSupportingVertex_0;
_.localGetSupportingVertexWithoutMargin = localGetSupportingVertexWithoutMargin_0;
_.typeId$ = 43;
function $SphereShape(this$static, radius){
  $$init_36(this$static);
  this$static.implicitShapeDimensions.x = radius;
  return this$static;
}

function $getRadius(this$static){
  return this$static.implicitShapeDimensions.x * this$static.localScaling.x;
}

function calculateLocalInertia_1(mass, inertia){
  var elem;
  elem = 0.4000000059604645 * mass * this.implicitShapeDimensions.x * this.localScaling.x * this.implicitShapeDimensions.x * this.localScaling.x;
  inertia.x = elem;
  inertia.y = elem;
  inertia.z = elem;
}

--></script>
<script><!--
function getAabb_2(t, aabbMin, aabbMax){
  var center, extent;
  center = t.origin;
  extent = $Vector3f_2(new Vector3f);
  $set_8(extent, this.implicitShapeDimensions.x * this.localScaling.x, this.implicitShapeDimensions.x * this.localScaling.x, this.implicitShapeDimensions.x * this.localScaling.x);
  $sub(aabbMin, center, extent);
  $add_1(aabbMax, center, extent);
}

function getClass_74(){
  return Lcom_bulletphysics_gwt_client_collision_shapes_SphereShape_2_classLit;
}

function getMargin_0(){
  return this.implicitShapeDimensions.x * this.localScaling.x;
}

function getShapeType_0(){
  return $clinit_12() , SPHERE_SHAPE_PROXYTYPE;
}

function localGetSupportingVertexWithoutMargin_1(vec, out){
  out.x = 0;
  out.y = 0;
  out.z = 0;
  return out;
}

function SphereShape(){
}

_ = SphereShape.prototype = new ConvexInternalShape;
_.calculateLocalInertia = calculateLocalInertia_1;
_.getAabb = getAabb_2;
_.getClass$ = getClass_74;
_.getMargin = getMargin_0;
_.getShapeType = getShapeType_0;
_.localGetSupportingVertexWithoutMargin = localGetSupportingVertexWithoutMargin_1;
_.typeId$ = 44;
function $TriangleShape(this$static){
  $$init_36(this$static);
  $$init_37(this$static);
  this$static.vertices1 = initValues(_3Lcom_bulletphysics_gwt_client_vecmath_Vector3f_2_classLit, 143, 53, [$Vector3f_2(new Vector3f), $Vector3f_2(new Vector3f), $Vector3f_2(new Vector3f)]);
  return this$static;
}

function calculateLocalInertia_2(mass, inertia){
  inertia.x = 0;
  inertia.y = 0;
  inertia.z = 0;
}

function getAabb_3(t, aabbMin, aabbMax){
  $getAabbSlow(this, t, aabbMin, aabbMax);
}

function getClass_75(){
  return Lcom_bulletphysics_gwt_client_collision_shapes_TriangleShape_2_classLit;
}

function getNumVertices_0(){
  return 3;
}

function getShapeType_1(){
  return $clinit_12() , TRIANGLE_SHAPE_PROXYTYPE;
}

function getVertex_0(index, vert){
  $set_9(vert, this.vertices1[index]);
}

function localGetSupportingVertexWithoutMargin_2(dir, out){
  var dots;
  dots = $Vector3f_2(new Vector3f);
  $set_8(dots, $dot(dir, this.vertices1[0]), $dot(dir, this.vertices1[1]), $dot(dir, this.vertices1[2]));
  $set_9(out, this.vertices1[maxAxis(dots)]);
  return out;
}

function TriangleShape(){
}

_ = TriangleShape.prototype = new PolyhedralConvexShape;
_.calculateLocalInertia = calculateLocalInertia_2;
_.getAabb = getAabb_3;
_.getClass$ = getClass_75;
_.getNumVertices = getNumVertices_0;
_.getShapeType = getShapeType_1;
_.getVertex = getVertex_0;
_.localGetSupportingVertexWithoutMargin = localGetSupportingVertexWithoutMargin_2;
_.typeId$ = 45;
function getClass_76(){
  return Lcom_bulletphysics_gwt_client_dynamics_DynamicsWorld_2_classLit;
}

function DynamicsWorld(){
}

_ = DynamicsWorld.prototype = new CollisionWorld;
_.getClass$ = getClass_76;
_.typeId$ = 0;
function $clinit_89(){
  $clinit_89 = nullMethod;
  sortConstraintOnIslandPredicate = new DiscreteDynamicsWorld$1;
}

function $DiscreteDynamicsWorld(this$static, dispatcher, pairCache, constraintSolver){
  $clinit_89();
  this$static.collisionObjects = $ArrayList(new ArrayList);
  this$static.dispatchInfo = $DispatcherInfo(new DispatcherInfo);
  this$static.dispatcher1 = dispatcher;
  this$static.broadphasePairCache = pairCache;
  this$static.solverInfo = new ContactSolverInfo;
  this$static.constraints = $ArrayList(new ArrayList);
  this$static.gravity = $Vector3f(new Vector3f, 0, -10, 0);
  this$static.vehicles = $ArrayList(new ArrayList);
  this$static.sortedConstraints = $ArrayList(new ArrayList);
  this$static.solverCallback = new DiscreteDynamicsWorld$InplaceSolverIslandCallback;
  this$static.constraintSolver = constraintSolver;
  !this$static.constraintSolver && (this$static.constraintSolver = $SequentialImpulseConstraintSolver(new SequentialImpulseConstraintSolver));
  this$static.islandManager = $SimulationIslandManager(new SimulationIslandManager);
  return this$static;
}

function $addRigidBody(this$static, body){
  var collisionFilterGroup, collisionFilterMask, isDynamic, maxAabb, minAabb, trans;
  (body.collisionFlags & 3) == 0 && $setGravity_0(body, this$static.gravity);
  if (body.collisionShape) {
    isDynamic = !((body.collisionFlags & 1) != 0 || (body.collisionFlags & 2) != 0);
    collisionFilterGroup = isDynamic?1:2;
    collisionFilterMask = isDynamic?-1:-3;
    $add_7(this$static.collisionObjects, body);
    trans = $getWorldTransform(body, $Transform(new Transform));
    minAabb = $Vector3f_2(new Vector3f);
    maxAabb = $Vector3f_2(new Vector3f);
    body.collisionShape.getAabb(trans, minAabb, maxAabb);
    body.collisionShape.getShapeType();
    body.broadphaseHandle = $createProxy(this$static.broadphasePairCache, minAabb, maxAabb, body, collisionFilterGroup, collisionFilterMask);
  }
}

function $applyGravity(this$static){
  var body, colObj, i;
  for (i = 0; i < this$static.collisionObjects.size; ++i) {
    colObj = dynamicCast($get_6(this$static.collisionObjects, i), 17);
    body = upcast(colObj);
    !!body && body.activationState1 != 2 && body.activationState1 != 5 && $applyGravity_0(body);
  }
}

function $calculateSimulationIslands(this$static){
  var i, numConstraints;
  $clinit_1();
  try {
    $updateActivationState(this$static.islandManager, this$static);
    numConstraints = this$static.constraints.size;
    for (i = 0; i < numConstraints; ++i) {
      throwClassCastExceptionUnlessNull($get_6(this$static.constraints, i));
      null.nullMethod();
      null.nullMethod();
    }
    $storeIslandActivationState(this$static.islandManager, this$static);
  }
   finally {
  }
}

function $clearForces(this$static){
  var body, colObj, i;
  for (i = 0; i < this$static.collisionObjects.size; ++i) {
    colObj = dynamicCast($get_6(this$static.collisionObjects, i), 17);
    body = upcast(colObj);
    if (body) {
      $set_8(body.totalForce, 0, 0, 0);
      $set_8(body.totalTorque, 0, 0, 0);
    }
  }
}

function $integrateTransforms(this$static, timeStep){
  var body, colObj, i, predictedTrans;
  $clinit_1();
  try {
    predictedTrans = $Transform(new Transform);
    for (i = 0; i < this$static.collisionObjects.size; ++i) {
      colObj = dynamicCast($get_6(this$static.collisionObjects, i), 17);
      body = upcast(colObj);
      if (body) {
        if (body.activationState1 != 2 && body.activationState1 != 5 && (body.collisionFlags & 3) == 0) {
          integrateTransform(body.worldTransform, body.linearVelocity, body.angularVelocity, timeStep, predictedTrans);
          (body.collisionFlags & 3) != 0?$set_3(body.interpolationWorldTransform, body.worldTransform):$set_3(body.interpolationWorldTransform, predictedTrans);
          $getLinearVelocity(body, body.interpolationLinearVelocity);
          $getAngularVelocity(body, body.interpolationAngularVelocity);
          $set_3(body.worldTransform, predictedTrans);
          $updateInertiaTensor(body);
        }
      }
    }
  }
   finally {
  }
}

function $internalSingleStepSimulation(this$static, timeStep){
  $clinit_1();
  try {
    $predictUnconstraintMotion(this$static, timeStep);
    $performDiscreteCollisionDetection(this$static);
    $calculateSimulationIslands(this$static);
    this$static.solverInfo.timeStep = timeStep;
    $solveConstraints(this$static, this$static.solverInfo);
    $integrateTransforms(this$static, timeStep);
    $updateVehicles(this$static);
    $updateActivationState_0(this$static, timeStep);
  }
   finally {
  }
}

function $predictUnconstraintMotion(this$static, timeStep){
  var body, colObj, i, tmpTrans;
  $clinit_1();
  try {
    tmpTrans = $Transform(new Transform);
    for (i = 0; i < this$static.collisionObjects.size; ++i) {
      colObj = dynamicCast($get_6(this$static.collisionObjects, i), 17);
      body = upcast(colObj);
      if (body) {
        if ((body.collisionFlags & 3) == 0) {
          if (body.activationState1 != 2 && body.activationState1 != 5) {
            $integrateVelocities(body, timeStep);
            $applyDamping(body, timeStep);
            $predictIntegratedTransform(body, timeStep, ($set_3(tmpTrans, body.interpolationWorldTransform) , tmpTrans));
          }
        }
      }
    }
  }
   finally {
  }
}

function $saveKinematicState(this$static, timeStep){
  var body, colObj, i;
  for (i = 0; i < this$static.collisionObjects.size; ++i) {
    colObj = dynamicCast($get_6(this$static.collisionObjects, i), 17);
    body = upcast(colObj);
    !!body && body.activationState1 != 2 && (body.collisionFlags & 2) != 0 && $saveKinematicState_0(body, timeStep);
  }
}

function $setGravity(this$static, gravity){
  var body, colObj, i;
  $set_9(this$static.gravity, gravity);
  for (i = 0; i < this$static.collisionObjects.size; ++i) {
    colObj = dynamicCast($get_6(this$static.collisionObjects, i), 17);
    body = upcast(colObj);
    !!body && (body.inverseMass != 0 && $scale(body.gravity, 1 / body.inverseMass, gravity) , undefined);
  }
}

function $solveConstraints(this$static, solverInfo){
  var constraintsPtr, i;
  $clinit_1();
  try {
    $clear(this$static.sortedConstraints);
    for (i = 0; i < this$static.constraints.size; ++i) {
      $add_7(this$static.sortedConstraints, throwClassCastExceptionUnlessNull($get_6(this$static.constraints, i)));
    }
    quickSort(this$static.sortedConstraints, sortConstraintOnIslandPredicate);
    constraintsPtr = this$static.constraints.size != 0?this$static.sortedConstraints:null;
    $init_10(this$static.solverCallback, solverInfo, this$static.constraintSolver, constraintsPtr, this$static.sortedConstraints.size);
    $buildAndProcessIslands(this$static.islandManager, this$static.dispatcher1, this$static.collisionObjects, this$static.solverCallback);
  }
   finally {
  }
}

function $stepSimulation(this$static, timeStep, maxSubSteps, fixedTimeStep){
  var clampedSimulationSteps, i, numSimulationSubSteps, t0;
  $clinit_108();
  root.totalCalls = 0;
  ($clinit_1() , gProfileClock).startTime = fromDouble((new Date).getTime());
  $call(root);
  frameCounter = 0;
  $getTimeMicroseconds(gProfileClock);
  t0 = fromDouble((new Date).getTime());
  try {
    numSimulationSubSteps = 0;
    if (maxSubSteps != 0) {
      this$static.localTime += timeStep;
      if (this$static.localTime >= fixedTimeStep) {
        numSimulationSubSteps = ~~Math.max(Math.min(this$static.localTime / fixedTimeStep, 2147483647), -2147483648);
        this$static.localTime -= numSimulationSubSteps * fixedTimeStep;
      }
    }
     else {
      fixedTimeStep = timeStep;
      this$static.localTime = timeStep;
      if ((timeStep < 0?-timeStep:timeStep) < 1.1920928955078125E-7) {
        numSimulationSubSteps = 0;
        maxSubSteps = 0;
      }
       else {
        numSimulationSubSteps = 1;
        maxSubSteps = 1;
      }
    }
    if (numSimulationSubSteps != 0) {
      $saveKinematicState(this$static, fixedTimeStep);
      $applyGravity(this$static);
      clampedSimulationSteps = numSimulationSubSteps > maxSubSteps?maxSubSteps:numSimulationSubSteps;
      for (i = 0; i < clampedSimulationSteps; ++i) {
        $internalSingleStepSimulation(this$static, fixedTimeStep);
        $synchronizeMotionStates(this$static);
      }
    }
    $synchronizeMotionStates(this$static);
    $clearForces(this$static);
    ++frameCounter;
    return numSimulationSubSteps;
  }
   finally {
    stepSimulationTime = sub(fromDouble((new Date).getTime()), t0);
  }
}

function $synchronizeMotionStates(this$static){
  var body, colObj, i, interpolatedTransform, tmpAngVel, tmpLinVel, tmpTrans;
  interpolatedTransform = $Transform(new Transform);
  tmpTrans = $Transform(new Transform);
  tmpLinVel = $Vector3f_2(new Vector3f);
  tmpAngVel = $Vector3f_2(new Vector3f);
  for (i = 0; i < this$static.collisionObjects.size; ++i) {
    colObj = dynamicCast($get_6(this$static.collisionObjects, i), 17);
    body = upcast(colObj);
    if (!!body && !!body.optionalMotionState && (body.collisionFlags & 3) == 0) {
      integrateTransform(($set_3(tmpTrans, body.interpolationWorldTransform) , tmpTrans), ($set_9(tmpLinVel, body.interpolationLinearVelocity) , tmpLinVel), ($set_9(tmpAngVel, body.interpolationAngularVelocity) , tmpAngVel), this$static.localTime, interpolatedTransform);
      $setWorldTransform(body.optionalMotionState, interpolatedTransform);
    }
  }
}

function $updateActivationState_0(this$static, timeStep){
  var body, colObj, i;
  $clinit_1();
  try {
    for (i = 0; i < this$static.collisionObjects.size; ++i) {
      colObj = dynamicCast($get_6(this$static.collisionObjects, i), 17);
      body = upcast(colObj);
      if (body) {
        $updateDeactivation(body, timeStep);
        $wantsSleeping(body)?(body.collisionFlags & 3) != 0?(body.activationState1 != 4 && body.activationState1 != 5 && (body.activationState1 = 2) , undefined):body.activationState1 == 1 && (body.activationState1 != 4 && body.activationState1 != 5 && (body.activationState1 = 3) , undefined):body.activationState1 != 4 && (body.activationState1 != 4 && body.activationState1 != 5 && (body.activationState1 = 1) , undefined);
      }
    }
  }
   finally {
  }
}

function $updateVehicles(this$static){
  var i;
  $clinit_1();
  try {
    for (i = 0; i < this$static.vehicles.size; ++i) {
      throwClassCastExceptionUnlessNull($get_6(this$static.vehicles, i));
      null.nullMethod();
    }
  }
   finally {
  }
}

function getClass_77(){
  return Lcom_bulletphysics_gwt_client_dynamics_DiscreteDynamicsWorld_2_classLit;
}

function getConstraintIslandId(){
  $clinit_89();
  var islandId;
  null.nullMethod();
  null.nullMethod();
  islandId = null.nullMethod() >= 0?null.nullMethod():null.nullMethod();
  return islandId;
}

function DiscreteDynamicsWorld(){
}

_ = DiscreteDynamicsWorld.prototype = new DynamicsWorld;
_.getClass$ = getClass_77;
_.typeId$ = 0;
_.constraintSolver = null;
_.islandManager = null;
_.localTime = 0.01666666753590107;
var sortConstraintOnIslandPredicate;
function $compare_1(){
  var lIslandId0, rIslandId0;
  rIslandId0 = getConstraintIslandId();
  lIslandId0 = getConstraintIslandId();
  return lIslandId0 < rIslandId0?-1:1;
}

function compare_2(p0, p1){
  return $compare_1((throwClassCastExceptionUnlessNull(p0) , throwClassCastExceptionUnlessNull(p1)));
}

function getClass_78(){
  return Lcom_bulletphysics_gwt_client_dynamics_DiscreteDynamicsWorld$1_2_classLit;
}

function DiscreteDynamicsWorld$1(){
}

_ = DiscreteDynamicsWorld$1.prototype = new Object_0;
_.compare = compare_2;
_.getClass$ = getClass_78;
_.typeId$ = 0;
function $init_10(this$static, solverInfo, solver, sortedConstraints, numConstraints){
  this$static.solverInfo = solverInfo;
  this$static.solver = solver;
  this$static.sortedConstraints = sortedConstraints;
  this$static.numConstraints = numConstraints;
}

function $processIsland(this$static, manifolds, manifolds_offset, numManifolds, islandId){
  var i, numCurConstraints, startConstraint_idx;
  if (islandId < 0) {
    $solveGroup(this$static.solver, manifolds, manifolds_offset, numManifolds, this$static.sortedConstraints, 0, this$static.numConstraints, this$static.solverInfo);
  }
   else {
    startConstraint_idx = -1;
    numCurConstraints = 0;
    for (i = 0; i < this$static.numConstraints; ++i) {
      if (getConstraintIslandId(throwClassCastExceptionUnlessNull($get_6(this$static.sortedConstraints, i))) == islandId) {
        startConstraint_idx = i;
        break;
      }
    }
    for (; i < this$static.numConstraints; ++i) {
      getConstraintIslandId(throwClassCastExceptionUnlessNull($get_6(this$static.sortedConstraints, i))) == islandId && ++numCurConstraints;
    }
    numManifolds + numCurConstraints > 0 && $solveGroup(this$static.solver, manifolds, manifolds_offset, numManifolds, this$static.sortedConstraints, startConstraint_idx, numCurConstraints, this$static.solverInfo);
  }
}

function getClass_79(){
  return Lcom_bulletphysics_gwt_client_dynamics_DiscreteDynamicsWorld$InplaceSolverIslandCallback_2_classLit;
}

function DiscreteDynamicsWorld$InplaceSolverIslandCallback(){
}

_ = DiscreteDynamicsWorld$InplaceSolverIslandCallback.prototype = new Object_0;
_.getClass$ = getClass_79;
_.typeId$ = 0;
_.numConstraints = 0;
_.solver = null;
_.solverInfo = null;
_.sortedConstraints = null;
function $RigidBody(this$static, constructionInfo){
  this$static.worldTransform = $Transform(new Transform);
  this$static.interpolationWorldTransform = $Transform(new Transform);
  this$static.interpolationLinearVelocity = $Vector3f_2(new Vector3f);
  this$static.interpolationAngularVelocity = $Vector3f_2(new Vector3f);
  this$static.internalType = ($clinit_28() , COLLISION_OBJECT);
  this$static.collisionFlags = 1;
  this$static.islandTag1 = -1;
  this$static.companionId = -1;
  this$static.activationState1 = 1;
  this$static.friction = 0.5;
  this$static.hitFraction = 1;
  this$static.invInertiaTensorWorld = $Matrix3f_0(new Matrix3f);
  this$static.linearVelocity = $Vector3f_2(new Vector3f);
  this$static.angularVelocity = $Vector3f_2(new Vector3f);
  this$static.gravity = $Vector3f_2(new Vector3f);
  this$static.invInertiaLocal = $Vector3f_2(new Vector3f);
  this$static.totalForce = $Vector3f_2(new Vector3f);
  this$static.totalTorque = $Vector3f_2(new Vector3f);
  this$static.constraintRefs = $ArrayList(new ArrayList);
  this$static.internalType = RIGID_BODY;
  $set_8(this$static.linearVelocity, 0, 0, 0);
  $set_8(this$static.angularVelocity, 0, 0, 0);
  this$static.angularFactor = 1;
  $set_8(this$static.gravity, 0, 0, 0);
  $set_8(this$static.totalForce, 0, 0, 0);
  $set_8(this$static.totalTorque, 0, 0, 0);
  this$static.linearDamping = 0;
  this$static.angularDamping = 0.5;
  this$static.linearSleepingThreshold = 0.800000011920929;
  this$static.angularSleepingThreshold = 1;
  this$static.optionalMotionState = constructionInfo.motionState;
  this$static.additionalDamping = false;
  this$static.additionalDampingFactor = 0.004999999888241291;
  this$static.additionalLinearDampingThresholdSqr = 0.009999999776482582;
  this$static.additionalAngularDampingThresholdSqr = 0.009999999776482582;
  this$static.optionalMotionState?$getWorldTransform_0(this$static.optionalMotionState, this$static.worldTransform):$set_3(this$static.worldTransform, constructionInfo.startWorldTransform);
  $set_3(this$static.interpolationWorldTransform, this$static.worldTransform);
  $set_8(this$static.interpolationLinearVelocity, 0, 0, 0);
  $set_8(this$static.interpolationAngularVelocity, 0, 0, 0);
  this$static.friction = 0.5;
  this$static.restitution = 0;
  this$static.collisionShape = constructionInfo.collisionShape;
  this$static.debugBodyId = uniqueId++;
  $setMassProps(this$static, constructionInfo.mass, constructionInfo.localInertia);
  this$static.linearDamping = 0;
  this$static.angularDamping = 0;
  $updateInertiaTensor(this$static);
  return this$static;
}

function $applyDamping(this$static, timeStep){
  var angSpeed, dir, speed;
  $scale_0(this$static.linearVelocity, GEN_clamped(1 - timeStep * this$static.linearDamping, 0, 1));
  $scale_0(this$static.angularVelocity, GEN_clamped(1 - timeStep * this$static.angularDamping, 0, 1));
  if (this$static.additionalDamping) {
    if ($lengthSquared(this$static.angularVelocity) < this$static.additionalAngularDampingThresholdSqr && $lengthSquared(this$static.linearVelocity) < this$static.additionalLinearDampingThresholdSqr) {
      $scale_0(this$static.angularVelocity, this$static.additionalDampingFactor);
      $scale_0(this$static.linearVelocity, this$static.additionalDampingFactor);
    }
    speed = $length(this$static.linearVelocity);
    if (speed < this$static.linearDamping) {
      if (speed > 0.004999999888241291) {
        dir = $Vector3f_1(new Vector3f, this$static.linearVelocity);
        $normalize_1(dir);
        dir.x *= 0.004999999888241291;
        dir.y *= 0.004999999888241291;
        dir.z *= 0.004999999888241291;
        $sub_0(this$static.linearVelocity, dir);
      }
       else {
        $set_8(this$static.linearVelocity, 0, 0, 0);
      }
    }
    angSpeed = $length(this$static.angularVelocity);
    if (angSpeed < this$static.angularDamping) {
      if (angSpeed > 0.004999999888241291) {
        dir = $Vector3f_1(new Vector3f, this$static.angularVelocity);
        $normalize_1(dir);
        dir.x *= 0.004999999888241291;
        dir.y *= 0.004999999888241291;
        dir.z *= 0.004999999888241291;
        $sub_0(this$static.angularVelocity, dir);
      }
       else {
        $set_8(this$static.angularVelocity, 0, 0, 0);
      }
    }
  }
}

function $applyGravity_0(this$static){
  if ((this$static.collisionFlags & 3) != 0)
    return;
  $add_2(this$static.totalForce, this$static.gravity);
}

function $getAngularVelocity(this$static, out){
  $set_9(out, this$static.angularVelocity);
  return out;
}

function $getLinearVelocity(this$static, out){
  $set_9(out, this$static.linearVelocity);
  return out;
}

function $integrateVelocities(this$static, step){
  var angvel, tmp;
  if ((this$static.collisionFlags & 3) != 0) {
    return;
  }
  $scaleAdd(this$static.linearVelocity, this$static.inverseMass * step, this$static.totalForce, this$static.linearVelocity);
  tmp = $Vector3f_1(new Vector3f, this$static.totalTorque);
  $transform_0(this$static.invInertiaTensorWorld, tmp);
  $scaleAdd(this$static.angularVelocity, step, tmp, this$static.angularVelocity);
  angvel = $length(this$static.angularVelocity);
  angvel * step > 1.5707963705062866 && $scale_0(this$static.angularVelocity, 1.5707963705062866 / step / angvel);
}

function $predictIntegratedTransform(this$static, timeStep, predictedTransform){
  integrateTransform(this$static.worldTransform, this$static.linearVelocity, this$static.angularVelocity, timeStep, predictedTransform);
}

function $saveKinematicState_0(this$static, timeStep){
  if (timeStep != 0) {
    !!this$static.optionalMotionState && $getWorldTransform_0(this$static.optionalMotionState, this$static.worldTransform);
    calculateVelocity(this$static.interpolationWorldTransform, this$static.worldTransform, timeStep, this$static.linearVelocity, this$static.angularVelocity);
    $set_9(this$static.interpolationLinearVelocity, this$static.linearVelocity);
    $set_9(this$static.interpolationAngularVelocity, this$static.angularVelocity);
    $set_3(this$static.interpolationWorldTransform, this$static.worldTransform);
  }
}

function $setGravity_0(this$static, acceleration){
  this$static.inverseMass != 0 && $scale(this$static.gravity, 1 / this$static.inverseMass, acceleration);
}

function $setMassProps(this$static, mass, inertia){
  if (mass == 0) {
    this$static.collisionFlags |= 1;
    this$static.inverseMass = 0;
  }
   else {
    this$static.collisionFlags &= -2;
    this$static.inverseMass = 1 / mass;
  }
  $set_8(this$static.invInertiaLocal, inertia.x != 0?1 / inertia.x:0, inertia.y != 0?1 / inertia.y:0, inertia.z != 0?1 / inertia.z:0);
}

function $updateDeactivation(this$static, timeStep){
  if (this$static.activationState1 == 2 || this$static.activationState1 == 4) {
    return;
  }
  if ($lengthSquared($getLinearVelocity(this$static, $Vector3f_2(new Vector3f))) < this$static.linearSleepingThreshold * this$static.linearSleepingThreshold && $lengthSquared($getAngularVelocity(this$static, $Vector3f_2(new Vector3f))) < this$static.angularSleepingThreshold * this$static.angularSleepingThreshold) {
    this$static.deactivationTime += timeStep;
  }
   else {
    this$static.deactivationTime = 0;
    this$static.activationState1 != 4 && this$static.activationState1 != 5 && (this$static.activationState1 = 0);
  }
}

function $updateInertiaTensor(this$static){
  var mat1, mat2;
  mat1 = $Matrix3f_0(new Matrix3f);
  scale(mat1, this$static.worldTransform.basis, this$static.invInertiaLocal);
  mat2 = $Matrix3f(new Matrix3f, this$static.worldTransform.basis);
  $transpose(mat2);
  $mul_2(this$static.invInertiaTensorWorld, mat1, mat2);
}

function $wantsSleeping(this$static){
  if (this$static.activationState1 == 4) {
    return false;
  }
  if (this$static.activationState1 == 2 || this$static.activationState1 == 3) {
    return true;
  }
  if (this$static.deactivationTime > 2) {
    return true;
  }
  return false;
}

function checkCollideWithOverride_0(co){
  var i, otherRb;
  otherRb = upcast(co);
  if (!otherRb) {
    return true;
  }
  for (i = 0; i < this.constraintRefs.size; ++i) {
    throwClassCastExceptionUnlessNull($get_6(this.constraintRefs, i));
    if (null.nullMethod() == otherRb || null.nullMethod() == otherRb) {
      return false;
    }
  }
  return true;
}

function getClass_80(){
  return Lcom_bulletphysics_gwt_client_dynamics_RigidBody_2_classLit;
}

function upcast(colObj){
  if (colObj.internalType == ($clinit_28() , RIGID_BODY)) {
    return dynamicCast(colObj, 35);
  }
  return null;
}

function RigidBody(){
}

_ = RigidBody.prototype = new CollisionObject;
_.checkCollideWithOverride = checkCollideWithOverride_0;
_.getClass$ = getClass_80;
_.typeId$ = 46;
_.additionalAngularDampingThresholdSqr = 0;
_.additionalDamping = false;
_.additionalDampingFactor = 0;
_.additionalLinearDampingThresholdSqr = 0;
_.angularDamping = 0;
_.angularFactor = 0;
_.angularSleepingThreshold = 0;
_.debugBodyId = 0;
_.inverseMass = 0;
_.linearDamping = 0;
_.linearSleepingThreshold = 0;
_.optionalMotionState = null;
var uniqueId = 0;
function $RigidBodyConstructionInfo(this$static, mass, motionState, collisionShape, localInertia){
  this$static.startWorldTransform = $Transform(new Transform);
  this$static.localInertia = $Vector3f_2(new Vector3f);
  this$static.mass = mass;
  this$static.motionState = motionState;
  this$static.collisionShape = collisionShape;
  $set_9(this$static.localInertia, localInertia);
  $setIdentity(this$static.startWorldTransform);
  return this$static;
}

function getClass_81(){
  return Lcom_bulletphysics_gwt_client_dynamics_RigidBodyConstructionInfo_2_classLit;
}

function RigidBodyConstructionInfo(){
}

_ = RigidBodyConstructionInfo.prototype = new Object_0;
_.getClass$ = getClass_81;
_.typeId$ = 0;
_.collisionShape = null;
_.mass = 0;
_.motionState = null;
function getClass_82(){
  return Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_ConstraintSolver_2_classLit;
}

function ConstraintSolver(){
}

_ = ConstraintSolver.prototype = new Object_0;
_.getClass$ = getClass_82;
_.typeId$ = 0;
function $clinit_95(){
  $clinit_95 = nullMethod;
  resolveSingleCollision = new ContactConstraint$1;
  resolveSingleFriction = new ContactConstraint$2;
}

var resolveSingleCollision, resolveSingleFriction;
function getClass_83(){
  return Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_ContactConstraint$1_2_classLit;
}

function ContactConstraint$1(){
}

_ = ContactConstraint$1.prototype = new Object_0;
_.getClass$ = getClass_83;
_.typeId$ = 47;
function getClass_84(){
  return Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_ContactConstraint$2_2_classLit;
}

function ContactConstraint$2(){
}

_ = ContactConstraint$2.prototype = new Object_0;
_.getClass$ = getClass_84;
_.typeId$ = 48;
function $clinit_98(){
  $clinit_98 = nullMethod;
  DEFAULT_CONTACT_SOLVER_TYPE = $ContactConstraintEnum(new ContactConstraintEnum, 'DEFAULT_CONTACT_SOLVER_TYPE', 0);
  CONTACT_SOLVER_TYPE1 = $ContactConstraintEnum(new ContactConstraintEnum, 'CONTACT_SOLVER_TYPE1', 1);
  CONTACT_SOLVER_TYPE2 = $ContactConstraintEnum(new ContactConstraintEnum, 'CONTACT_SOLVER_TYPE2', 2);
  USER_CONTACT_SOLVER_TYPE1 = $ContactConstraintEnum(new ContactConstraintEnum, 'USER_CONTACT_SOLVER_TYPE1', 3);
  MAX_CONTACT_SOLVER_TYPES = $ContactConstraintEnum(new ContactConstraintEnum, 'MAX_CONTACT_SOLVER_TYPES', 4);
}

function $ContactConstraintEnum(this$static, enum$name, enum$ordinal){
  $clinit_98();
  this$static.name_0 = enum$name;
  this$static.ordinal = enum$ordinal;
  return this$static;
}

function getClass_85(){
  return Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_ContactConstraintEnum_2_classLit;
}

function values_5(){
  $clinit_98();
  return initValues(_3Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_ContactConstraintEnum_2_classLit, 138, 49, [DEFAULT_CONTACT_SOLVER_TYPE, CONTACT_SOLVER_TYPE1, CONTACT_SOLVER_TYPE2, USER_CONTACT_SOLVER_TYPE1, MAX_CONTACT_SOLVER_TYPES]);
}

function ContactConstraintEnum(){
}

_ = ContactConstraintEnum.prototype = new Enum;
_.getClass$ = getClass_85;
_.typeId$ = 49;
var CONTACT_SOLVER_TYPE1, CONTACT_SOLVER_TYPE2, DEFAULT_CONTACT_SOLVER_TYPE, MAX_CONTACT_SOLVER_TYPES, USER_CONTACT_SOLVER_TYPE1;
function getClass_86(){
  return Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_ContactSolverInfo_2_classLit;
}

function ContactSolverInfo(){
}

_ = ContactSolverInfo.prototype = new Object_0;
_.getClass$ = getClass_86;
_.typeId$ = 0;
_.timeStep = 0;
function $JacobianEntry(this$static){
  $Vector3f_2(new Vector3f);
  $Vector3f_2(new Vector3f);
  $Vector3f_2(new Vector3f);
  $Vector3f_2(new Vector3f);
  $Vector3f_2(new Vector3f);
  return this$static;
}

function getClass_87(){
  return Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_JacobianEntry_2_classLit;
}

function JacobianEntry(){
}

_ = JacobianEntry.prototype = new Object_0;
_.getClass$ = getClass_87;
_.typeId$ = 0;
function $clinit_102(){
  $clinit_102 = nullMethod;
  MAX_CONTACT_SOLVER_TYPES_0 = ($clinit_98() , MAX_CONTACT_SOLVER_TYPES).ordinal;
}

--></script>
<script><!--
function $$init_44(this$static){
  var i;
  this$static.gOrder = initDim(_3Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_SequentialImpulseConstraintSolver$OrderIndex_2_classLit, 140, 50, 16384, 0);
  for (i = 0; i < this$static.gOrder.length; ++i) {
    this$static.gOrder[i] = new SequentialImpulseConstraintSolver$OrderIndex;
  }
  this$static.bodiesPool = get_1(Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_SolverBody_2_classLit, ($clinit_125() , solverBodyFactory));
  this$static.constraintsPool = get_1(Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_SolverConstraint_2_classLit, solverConstraintFactory);
  get_1(Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_JacobianEntry_2_classLit, jacobianEntryFactory);
  this$static.tmpSolverBodyPool = $ArrayList(new ArrayList);
  this$static.tmpSolverConstraintPool = $ArrayList(new ArrayList);
  this$static.tmpSolverFrictionConstraintPool = $ArrayList(new ArrayList);
  this$static.orderTmpConstraintPool = $IntArrayList(new IntArrayList);
  this$static.orderFrictionConstraintPool = $IntArrayList(new IntArrayList);
  this$static.contactDispatch = initDims_0([_3_3Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_ContactSolverFunc_2_classLit, _3Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_ContactSolverFunc_2_classLit], [161, 139], [5, 36], [MAX_CONTACT_SOLVER_TYPES_0, MAX_CONTACT_SOLVER_TYPES_0], 0, 2, 0);
  this$static.frictionDispatch = initDims_0([_3_3Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_ContactSolverFunc_2_classLit, _3Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_ContactSolverFunc_2_classLit], [161, 139], [5, 36], [MAX_CONTACT_SOLVER_TYPES_0, MAX_CONTACT_SOLVER_TYPES_0], 0, 2, 0);
}

function $SequentialImpulseConstraintSolver(this$static){
  var i, j;
  $clinit_102();
  $$init_44(this$static);
  gContactDestroyedCallback = $SequentialImpulseConstraintSolver$1(new SequentialImpulseConstraintSolver$1, this$static);
  for (i = 0; i < MAX_CONTACT_SOLVER_TYPES_0; ++i) {
    for (j = 0; j < MAX_CONTACT_SOLVER_TYPES_0; ++j) {
      setCheck(this$static.contactDispatch[i], j, ($clinit_95() , resolveSingleCollision));
      setCheck(this$static.frictionDispatch[i], j, resolveSingleFriction);
    }
  }
  return this$static;
}

function $addFrictionConstraint(this$static, normalAxis, solverBodyIdA, solverBodyIdB, frictionIndex, cp, rel_pos1, rel_pos2, colObj0, colObj1, relaxation){
  var body0, body1, denom, denom0, denom1, ftorqueAxis1, solverConstraint, tmpMat, vec;
  body0 = upcast(colObj0);
  body1 = upcast(colObj1);
  solverConstraint = dynamicCast($get_1(this$static.constraintsPool), 42);
  $add_7(this$static.tmpSolverFrictionConstraintPool, solverConstraint);
  $set_9(solverConstraint.contactNormal, normalAxis);
  solverConstraint.solverBodyIdA = solverBodyIdA;
  solverConstraint.solverBodyIdB = solverBodyIdB;
  $clinit_107();
  solverConstraint.frictionIndex = frictionIndex;
  solverConstraint.friction = cp.combinedFriction;
  solverConstraint.originalContactPoint = null;
  solverConstraint.appliedImpulse = 0;
  solverConstraint.appliedPushImpulse = 0;
  solverConstraint.penetration = 0;
  ftorqueAxis1 = $Vector3f_2(new Vector3f);
  tmpMat = $Matrix3f_0(new Matrix3f);
  $cross(ftorqueAxis1, rel_pos1, solverConstraint.contactNormal);
  $set_9(solverConstraint.relpos1CrossNormal, ftorqueAxis1);
  if (body0) {
    $set_9(solverConstraint.angularComponentA, ftorqueAxis1);
    $transform_0(($set_6(tmpMat, body0.invInertiaTensorWorld) , tmpMat), solverConstraint.angularComponentA);
  }
   else {
    $set_8(solverConstraint.angularComponentA, 0, 0, 0);
  }
  $cross(ftorqueAxis1, rel_pos2, solverConstraint.contactNormal);
  $set_9(solverConstraint.relpos2CrossNormal, ftorqueAxis1);
  if (body1) {
    $set_9(solverConstraint.angularComponentB, ftorqueAxis1);
    $transform_0(($set_6(tmpMat, body1.invInertiaTensorWorld) , tmpMat), solverConstraint.angularComponentB);
  }
   else {
    $set_8(solverConstraint.angularComponentB, 0, 0, 0);
  }
  vec = $Vector3f_2(new Vector3f);
  denom0 = 0;
  denom1 = 0;
  if (body0) {
    $cross(vec, solverConstraint.angularComponentA, rel_pos1);
    denom0 = body0.inverseMass + (normalAxis.x * vec.x + normalAxis.y * vec.y + normalAxis.z * vec.z);
  }
  if (body1) {
    $cross(vec, solverConstraint.angularComponentB, rel_pos2);
    denom1 = body1.inverseMass + (normalAxis.x * vec.x + normalAxis.y * vec.y + normalAxis.z * vec.z);
  }
  denom = relaxation / (denom0 + denom1);
  solverConstraint.jacDiagABInv = denom;
}

function $initSolverBody(solverBody, collisionObject){
  var rb;
  rb = upcast(collisionObject);
  if (rb) {
    $getAngularVelocity(rb, solverBody.angularVelocity);
    $set_9(solverBody.centerOfMassPosition, $getWorldTransform(collisionObject, $Transform(new Transform)).origin);
    solverBody.invMass = rb.inverseMass;
    $getLinearVelocity(rb, solverBody.linearVelocity);
    solverBody.originalBody = rb;
    solverBody.angularFactor = rb.angularFactor;
  }
   else {
    $set_8(solverBody.angularVelocity, 0, 0, 0);
    $set_9(solverBody.centerOfMassPosition, $getWorldTransform(collisionObject, $Transform(new Transform)).origin);
    solverBody.invMass = 0;
    $set_8(solverBody.linearVelocity, 0, 0, 0);
    solverBody.originalBody = null;
    solverBody.angularFactor = 1;
  }
  $set_8(solverBody.pushVelocity, 0, 0, 0);
  $set_8(solverBody.turnVelocity, 0, 0, 0);
}

function $randInt2(this$static, n){
  var r, un;
  un = n;
  r = (this$static.btSeed2 = 1664525 * this$static.btSeed2 + 1013904223 & -1 , this$static.btSeed2);
  if (compare_6(fromInt(un), P10000_longLit) <= 0) {
    r ^= r >>> 16;
    if (compare_6(fromInt(un), P100_longLit) <= 0) {
      r ^= r >>> 8;
      if (compare_6(fromInt(un), P10_longLit) <= 0) {
        r ^= r >>> 4;
        if (compare_6(fromInt(un), P4_longLit) <= 0) {
          r ^= r >>> 2;
          compare_6(fromInt(un), P2_longLit) <= 0 && (r ^= r >>> 1);
        }
      }
    }
  }
  return r % un < 0?-(r % un):r % un;
}

function $resolveSingleCollisionCombinedCacheFriendly(body1, body2, contactConstraint, solverInfo){
  var normalImpulse, oldNormalImpulse, penetrationImpulse, positionalError, rel_vel, sum, tmp, vel1Dotn, vel2Dotn, velocityError, velocityImpulse;
  vel1Dotn = $dot(contactConstraint.contactNormal, body1.linearVelocity) + $dot(contactConstraint.relpos1CrossNormal, body1.angularVelocity);
  vel2Dotn = $dot(contactConstraint.contactNormal, body2.linearVelocity) + $dot(contactConstraint.relpos2CrossNormal, body2.angularVelocity);
  rel_vel = vel1Dotn - vel2Dotn;
  positionalError = 0;
  positionalError = -contactConstraint.penetration * 0.20000000298023224 / solverInfo.timeStep;
  velocityError = contactConstraint.restitution - rel_vel;
  penetrationImpulse = positionalError * contactConstraint.jacDiagABInv;
  velocityImpulse = velocityError * contactConstraint.jacDiagABInv;
  normalImpulse = penetrationImpulse + velocityImpulse;
  oldNormalImpulse = contactConstraint.appliedImpulse;
  sum = oldNormalImpulse + normalImpulse;
  contactConstraint.appliedImpulse = 0 > sum?0:sum;
  normalImpulse = contactConstraint.appliedImpulse - oldNormalImpulse;
  tmp = $Vector3f_2(new Vector3f);
  $scale(tmp, body1.invMass, contactConstraint.contactNormal);
  $internalApplyImpulse(body1, tmp, contactConstraint.angularComponentA, normalImpulse);
  $scale(tmp, body2.invMass, contactConstraint.contactNormal);
  $internalApplyImpulse(body2, tmp, contactConstraint.angularComponentB, -normalImpulse);
  return normalImpulse;
}

function $resolveSingleFrictionCacheFriendly(body1, body2, contactConstraint, appliedNormalImpulse){
  var combinedFriction, j1, limit, oldTangentImpulse, rel_vel, tmp, vel1Dotn, vel2Dotn;
  combinedFriction = contactConstraint.friction;
  limit = appliedNormalImpulse * combinedFriction;
  if (appliedNormalImpulse > 0) {
    vel1Dotn = $dot(contactConstraint.contactNormal, body1.linearVelocity) + $dot(contactConstraint.relpos1CrossNormal, body1.angularVelocity);
    vel2Dotn = $dot(contactConstraint.contactNormal, body2.linearVelocity) + $dot(contactConstraint.relpos2CrossNormal, body2.angularVelocity);
    rel_vel = vel1Dotn - vel2Dotn;
    j1 = -rel_vel * contactConstraint.jacDiagABInv;
    oldTangentImpulse = contactConstraint.appliedImpulse;
    contactConstraint.appliedImpulse = oldTangentImpulse + j1;
    limit < contactConstraint.appliedImpulse?(contactConstraint.appliedImpulse = limit):contactConstraint.appliedImpulse < -limit && (contactConstraint.appliedImpulse = -limit);
    j1 = contactConstraint.appliedImpulse - oldTangentImpulse;
    tmp = $Vector3f_2(new Vector3f);
    $scale(tmp, body1.invMass, contactConstraint.contactNormal);
    $internalApplyImpulse(body1, tmp, contactConstraint.angularComponentA, j1);
    $scale(tmp, body2.invMass, contactConstraint.contactNormal);
    $internalApplyImpulse(body2, tmp, contactConstraint.angularComponentB, -j1);
  }
  return 0;
}

function $restitutionCurve(rel_vel, restitution){
  var rest;
  rest = restitution * -rel_vel;
  return rest;
}

function $solveGroup(this$static, manifoldPtr, manifold_offset, numManifolds, constraints, constraints_offset, numConstraints, infoGlobal){
  var value;
  $clinit_1();
  try {
    value = $solveGroupCacheFriendly(this$static, manifoldPtr, manifold_offset, numManifolds, constraints, constraints_offset, numConstraints, infoGlobal);
    return value;
  }
   finally {
  }
}

function $solveGroupCacheFriendly(this$static, manifoldPtr, manifold_offset, numManifolds, constraints, constraints_offset, numConstraints, infoGlobal){
  var i, j, numPoolConstraints, pt, solveManifold;
  $solveGroupCacheFriendlySetup(this$static, manifoldPtr, manifold_offset, numManifolds, constraints, constraints_offset, numConstraints, infoGlobal);
  $solveGroupCacheFriendlyIterations(this$static, constraints, constraints_offset, numConstraints, infoGlobal);
  numPoolConstraints = this$static.tmpSolverConstraintPool.size;
  for (j = 0; j < numPoolConstraints; ++j) {
    solveManifold = dynamicCast($get_6(this$static.tmpSolverConstraintPool, j), 42);
    pt = solveManifold.originalContactPoint;
    pt.appliedImpulse = solveManifold.appliedImpulse;
    pt.appliedImpulseLateral1 = dynamicCast($get_6(this$static.tmpSolverFrictionConstraintPool, solveManifold.frictionIndex), 42).appliedImpulse;
    pt.appliedImpulseLateral1 = dynamicCast($get_6(this$static.tmpSolverFrictionConstraintPool, solveManifold.frictionIndex + 1), 42).appliedImpulse;
  }
  for (i = 0; i < this$static.tmpSolverBodyPool.size; ++i) {
    $writebackVelocity(dynamicCast($get_6(this$static.tmpSolverBodyPool, i), 43));
    $add_7(this$static.bodiesPool.list, dynamicCast($get_6(this$static.tmpSolverBodyPool, i), 43));
  }
  $clear(this$static.tmpSolverBodyPool);
  for (i = 0; i < this$static.tmpSolverConstraintPool.size; ++i) {
    $add_7(this$static.constraintsPool.list, dynamicCast($get_6(this$static.tmpSolverConstraintPool, i), 42));
  }
  $clear(this$static.tmpSolverConstraintPool);
  for (i = 0; i < this$static.tmpSolverFrictionConstraintPool.size; ++i) {
    $add_7(this$static.constraintsPool.list, dynamicCast($get_6(this$static.tmpSolverFrictionConstraintPool, i), 42));
  }
  $clear(this$static.tmpSolverFrictionConstraintPool);
  return 0;
}

function $solveGroupCacheFriendlyIterations(this$static, constraints, constraints_offset, numConstraints, infoGlobal){
  var iteration, j, numConstraintPool, numFrictionPool, numFrictionPoolConstraints, numPoolConstraints, solveManifold, swapi, tmp, totalImpulse;
  $clinit_1();
  try {
    numConstraintPool = this$static.tmpSolverConstraintPool.size;
    numFrictionPool = this$static.tmpSolverFrictionConstraintPool.size;
    for (iteration = 0; iteration < 10; ++iteration) {
      if ((iteration & 7) == 0) {
        for (j = 0; j < numConstraintPool; ++j) {
          tmp = $get(this$static.orderTmpConstraintPool, j);
          swapi = $randInt2(this$static, j + 1);
          $set_4(this$static.orderTmpConstraintPool, j, $get(this$static.orderTmpConstraintPool, swapi));
          $set_4(this$static.orderTmpConstraintPool, swapi, tmp);
        }
        for (j = 0; j < numFrictionPool; ++j) {
          tmp = $get(this$static.orderFrictionConstraintPool, j);
          swapi = $randInt2(this$static, j + 1);
          $set_4(this$static.orderFrictionConstraintPool, j, $get(this$static.orderFrictionConstraintPool, swapi));
          $set_4(this$static.orderFrictionConstraintPool, swapi, tmp);
        }
      }
      for (j = 0; j < numConstraints; ++j) {
        throwClassCastExceptionUnlessNull((checkIndex(constraints_offset + j, constraints.size) , constraints.array[constraints_offset + j]));
        null.nullMethod().nullMethod() >= 0 && null.nullMethod().nullMethod() >= 0 && $writebackVelocity(dynamicCast($get_6(this$static.tmpSolverBodyPool, null.nullMethod().nullMethod()), 43));
        null.nullMethod().nullMethod() >= 0 && null.nullMethod().nullMethod() >= 0 && $writebackVelocity(dynamicCast($get_6(this$static.tmpSolverBodyPool, null.nullMethod().nullMethod()), 43));
        null.nullMethod();
        null.nullMethod().nullMethod() >= 0 && null.nullMethod().nullMethod() >= 0 && $readVelocity(dynamicCast($get_6(this$static.tmpSolverBodyPool, null.nullMethod().nullMethod()), 43));
        null.nullMethod().nullMethod() >= 0 && null.nullMethod().nullMethod() >= 0 && $readVelocity(dynamicCast($get_6(this$static.tmpSolverBodyPool, null.nullMethod().nullMethod()), 43));
      }
      numPoolConstraints = this$static.tmpSolverConstraintPool.size;
      for (j = 0; j < numPoolConstraints; ++j) {
        solveManifold = dynamicCast($get_6(this$static.tmpSolverConstraintPool, $get(this$static.orderTmpConstraintPool, j)), 42);
        $resolveSingleCollisionCombinedCacheFriendly(dynamicCast($get_6(this$static.tmpSolverBodyPool, solveManifold.solverBodyIdA), 43), dynamicCast($get_6(this$static.tmpSolverBodyPool, solveManifold.solverBodyIdB), 43), solveManifold, infoGlobal);
      }
      numFrictionPoolConstraints = this$static.tmpSolverFrictionConstraintPool.size;
      for (j = 0; j < numFrictionPoolConstraints; ++j) {
        solveManifold = dynamicCast($get_6(this$static.tmpSolverFrictionConstraintPool, $get(this$static.orderFrictionConstraintPool, j)), 42);
        totalImpulse = dynamicCast($get_6(this$static.tmpSolverConstraintPool, solveManifold.frictionIndex), 42).appliedImpulse + dynamicCast($get_6(this$static.tmpSolverConstraintPool, solveManifold.frictionIndex), 42).appliedPushImpulse;
        $resolveSingleFrictionCacheFriendly(dynamicCast($get_6(this$static.tmpSolverBodyPool, solveManifold.solverBodyIdA), 43), dynamicCast($get_6(this$static.tmpSolverBodyPool, solveManifold.solverBodyIdB), 43), solveManifold, totalImpulse);
      }
    }
    return 0;
  }
   finally {
  }
}

function $solveGroupCacheFriendlySetup(this$static, manifoldPtr, manifold_offset, numManifolds, constraints, constraints_offset, numConstraints, infoGlobal){
  var colObj0, colObj1, cp, denom, denom0, denom1, frictionConstraint1, frictionConstraint2, frictionIndex, i, j, lat_rel_vel, manifold, numConstraintPool, numFrictionPool, penVel, pos1, pos2, rb0, rb1, rel_pos1, rel_pos2, rel_vel, relaxation, solverBody, solverBodyIdA, solverBodyIdB, solverConstraint, tmp, tmpMat, tmpTrans, torqueAxis0, torqueAxis1, vec, vel, vel1, vel2, vec_0, vec_1;
  $clinit_1();
  try {
    if (numConstraints + numManifolds == 0) {
      return 0;
    }
    manifold = null;
    colObj0 = null;
    colObj1 = null;
    tmpTrans = $Transform(new Transform);
    rel_pos1 = $Vector3f_2(new Vector3f);
    rel_pos2 = $Vector3f_2(new Vector3f);
    pos1 = $Vector3f_2(new Vector3f);
    pos2 = $Vector3f_2(new Vector3f);
    vel = $Vector3f_2(new Vector3f);
    torqueAxis0 = $Vector3f_2(new Vector3f);
    torqueAxis1 = $Vector3f_2(new Vector3f);
    vel1 = $Vector3f_2(new Vector3f);
    vel2 = $Vector3f_2(new Vector3f);
    vec = $Vector3f_2(new Vector3f);
    tmpMat = $Matrix3f_0(new Matrix3f);
    for (i = 0; i < numManifolds; ++i) {
      manifold = dynamicCast((checkIndex(manifold_offset + i, manifoldPtr.size) , manifoldPtr.array[manifold_offset + i]), 16);
      colObj0 = manifold.body0;
      colObj1 = manifold.body1;
      solverBodyIdA = -1;
      solverBodyIdB = -1;
      if (manifold.cachedPoints != 0) {
        if (colObj0.islandTag1 >= 0) {
          if (colObj0.companionId >= 0) {
            solverBodyIdA = colObj0.companionId;
          }
           else {
            solverBodyIdA = this$static.tmpSolverBodyPool.size;
            solverBody = dynamicCast($get_1(this$static.bodiesPool), 43);
            $add_7(this$static.tmpSolverBodyPool, solverBody);
            $initSolverBody(solverBody, colObj0);
            colObj0.companionId = solverBodyIdA;
          }
        }
         else {
          solverBodyIdA = this$static.tmpSolverBodyPool.size;
          solverBody = dynamicCast($get_1(this$static.bodiesPool), 43);
          $add_7(this$static.tmpSolverBodyPool, solverBody);
          $initSolverBody(solverBody, colObj0);
        }
        if (colObj1.islandTag1 >= 0) {
          if (colObj1.companionId >= 0) {
            solverBodyIdB = colObj1.companionId;
          }
           else {
            solverBodyIdB = this$static.tmpSolverBodyPool.size;
            solverBody = dynamicCast($get_1(this$static.bodiesPool), 43);
            $add_7(this$static.tmpSolverBodyPool, solverBody);
            $initSolverBody(solverBody, colObj1);
            colObj1.companionId = solverBodyIdB;
          }
        }
         else {
          solverBodyIdB = this$static.tmpSolverBodyPool.size;
          solverBody = dynamicCast($get_1(this$static.bodiesPool), 43);
          $add_7(this$static.tmpSolverBodyPool, solverBody);
          $initSolverBody(solverBody, colObj1);
        }
      }
      for (j = 0; j < manifold.cachedPoints; ++j) {
        cp = manifold.pointCache[j];
        if (cp.distance1 <= 0) {
          $set_9(pos1, cp.positionWorldOnA);
          $set_9(pos2, cp.positionWorldOnB);
          $sub(rel_pos1, pos1, ($set_3(tmpTrans, colObj0.worldTransform) , tmpTrans).origin);
          $sub(rel_pos2, pos2, ($set_3(tmpTrans, colObj1.worldTransform) , tmpTrans).origin);
          relaxation = 1;
          frictionIndex = this$static.tmpSolverConstraintPool.size;
          solverConstraint = dynamicCast($get_1(this$static.constraintsPool), 42);
          $add_7(this$static.tmpSolverConstraintPool, solverConstraint);
          rb0 = upcast(colObj0);
          rb1 = upcast(colObj1);
          solverConstraint.solverBodyIdA = solverBodyIdA;
          solverConstraint.solverBodyIdB = solverBodyIdB;
          $clinit_107();
          solverConstraint.originalContactPoint = cp;
          $cross(torqueAxis0, rel_pos1, cp.normalWorldOnB);
          if (rb0) {
            $set_9(solverConstraint.angularComponentA, torqueAxis0);
            $transform_0(($set_6(tmpMat, rb0.invInertiaTensorWorld) , tmpMat), solverConstraint.angularComponentA);
          }
           else {
            $set_8(solverConstraint.angularComponentA, 0, 0, 0);
          }
          $cross(torqueAxis1, rel_pos2, cp.normalWorldOnB);
          if (rb1) {
            $set_9(solverConstraint.angularComponentB, torqueAxis1);
            $transform_0(($set_6(tmpMat, rb1.invInertiaTensorWorld) , tmpMat), solverConstraint.angularComponentB);
          }
           else {
            $set_8(solverConstraint.angularComponentB, 0, 0, 0);
          }
          denom0 = 0;
          denom1 = 0;
          if (rb0) {
            $cross(vec, solverConstraint.angularComponentA, rel_pos1);
            denom0 = rb0.inverseMass + $dot(cp.normalWorldOnB, vec);
          }
          if (rb1) {
            $cross(vec, solverConstraint.angularComponentB, rel_pos2);
            denom1 = rb1.inverseMass + $dot(cp.normalWorldOnB, vec);
          }
          denom = relaxation / (denom0 + denom1);
          solverConstraint.jacDiagABInv = denom;
          $set_9(solverConstraint.contactNormal, cp.normalWorldOnB);
          $cross(solverConstraint.relpos1CrossNormal, rel_pos1, cp.normalWorldOnB);
          $cross(solverConstraint.relpos2CrossNormal, rel_pos2, cp.normalWorldOnB);
          rb0?(vec_0 = vel1 , $cross(vec_0, rb0.angularVelocity, rel_pos1) , $add_2(vec_0, rb0.linearVelocity) , vel1):(vel1.x = 0 , vel1.y = 0 , vel1.z = 0 , undefined);
          rb1?(vec_1 = vel2 , $cross(vec_1, rb1.angularVelocity, rel_pos2) , $add_2(vec_1, rb1.linearVelocity) , vel2):(vel2.x = 0 , vel2.y = 0 , vel2.z = 0 , undefined);
          $sub(vel, vel1, vel2);
          rel_vel = $dot(cp.normalWorldOnB, vel);
          solverConstraint.penetration = min_0(cp.distance1, 0);
          solverConstraint.friction = cp.combinedFriction;
          solverConstraint.restitution = $restitutionCurve(rel_vel, cp.combinedRestitution);
          solverConstraint.restitution <= 0 && (solverConstraint.restitution = 0);
          penVel = -solverConstraint.penetration / infoGlobal.timeStep;
          solverConstraint.restitution > penVel && (solverConstraint.penetration = 0);
          tmp = $Vector3f_2(new Vector3f);
          solverConstraint.appliedImpulse = cp.appliedImpulse * 0.8500000238418579;
          if (rb0) {
            $scale(tmp, rb0.inverseMass, solverConstraint.contactNormal);
            $internalApplyImpulse(dynamicCast($get_6(this$static.tmpSolverBodyPool, solverConstraint.solverBodyIdA), 43), tmp, solverConstraint.angularComponentA, solverConstraint.appliedImpulse);
          }
          if (rb1) {
            $scale(tmp, rb1.inverseMass, solverConstraint.contactNormal);
            $internalApplyImpulse(dynamicCast($get_6(this$static.tmpSolverBodyPool, solverConstraint.solverBodyIdB), 43), tmp, solverConstraint.angularComponentB, -solverConstraint.appliedImpulse);
          }
          solverConstraint.appliedPushImpulse = 0;
          solverConstraint.frictionIndex = this$static.tmpSolverFrictionConstraintPool.size;
          if (cp.lateralFrictionInitialized) {
            $addFrictionConstraint(this$static, cp.lateralFrictionDir1, solverBodyIdA, solverBodyIdB, frictionIndex, cp, rel_pos1, rel_pos2, colObj0, colObj1, relaxation);
            $addFrictionConstraint(this$static, cp.lateralFrictionDir2, solverBodyIdA, solverBodyIdB, frictionIndex, cp, rel_pos1, rel_pos2, colObj0, colObj1, relaxation);
          }
           else {
            $scale(cp.lateralFrictionDir1, rel_vel, cp.normalWorldOnB);
            $sub(cp.lateralFrictionDir1, vel, cp.lateralFrictionDir1);
            lat_rel_vel = $lengthSquared(cp.lateralFrictionDir1);
            if (lat_rel_vel > 1.1920928955078125E-7) {
              $scale_0(cp.lateralFrictionDir1, 1 / Math.sqrt(lat_rel_vel));
              $addFrictionConstraint(this$static, cp.lateralFrictionDir1, solverBodyIdA, solverBodyIdB, frictionIndex, cp, rel_pos1, rel_pos2, colObj0, colObj1, relaxation);
              $cross(cp.lateralFrictionDir2, cp.lateralFrictionDir1, cp.normalWorldOnB);
              $normalize_1(cp.lateralFrictionDir2);
              $addFrictionConstraint(this$static, cp.lateralFrictionDir2, solverBodyIdA, solverBodyIdB, frictionIndex, cp, rel_pos1, rel_pos2, colObj0, colObj1, relaxation);
            }
             else {
              planeSpace1(cp.normalWorldOnB, cp.lateralFrictionDir1, cp.lateralFrictionDir2);
              $addFrictionConstraint(this$static, cp.lateralFrictionDir1, solverBodyIdA, solverBodyIdB, frictionIndex, cp, rel_pos1, rel_pos2, colObj0, colObj1, relaxation);
              $addFrictionConstraint(this$static, cp.lateralFrictionDir2, solverBodyIdA, solverBodyIdB, frictionIndex, cp, rel_pos1, rel_pos2, colObj0, colObj1, relaxation);
            }
            cp.lateralFrictionInitialized = true;
          }
          frictionConstraint1 = dynamicCast($get_6(this$static.tmpSolverFrictionConstraintPool, solverConstraint.frictionIndex), 42);
          frictionConstraint1.appliedImpulse = cp.appliedImpulseLateral1 * 0.8500000238418579;
          if (rb0) {
            $scale(tmp, rb0.inverseMass, frictionConstraint1.contactNormal);
            $internalApplyImpulse(dynamicCast($get_6(this$static.tmpSolverBodyPool, solverConstraint.solverBodyIdA), 43), tmp, frictionConstraint1.angularComponentA, frictionConstraint1.appliedImpulse);
          }
          if (rb1) {
            $scale(tmp, rb1.inverseMass, frictionConstraint1.contactNormal);
            $internalApplyImpulse(dynamicCast($get_6(this$static.tmpSolverBodyPool, solverConstraint.solverBodyIdB), 43), tmp, frictionConstraint1.angularComponentB, -frictionConstraint1.appliedImpulse);
          }
          frictionConstraint2 = dynamicCast($get_6(this$static.tmpSolverFrictionConstraintPool, solverConstraint.frictionIndex + 1), 42);
          frictionConstraint2.appliedImpulse = cp.appliedImpulseLateral2 * 0.8500000238418579;
          if (rb0) {
            $scale(tmp, rb0.inverseMass, frictionConstraint2.contactNormal);
            $internalApplyImpulse(dynamicCast($get_6(this$static.tmpSolverBodyPool, solverConstraint.solverBodyIdA), 43), tmp, frictionConstraint2.angularComponentA, frictionConstraint2.appliedImpulse);
          }
          if (rb1) {
            $scale(tmp, rb1.inverseMass, frictionConstraint2.contactNormal);
            $internalApplyImpulse(dynamicCast($get_6(this$static.tmpSolverBodyPool, solverConstraint.solverBodyIdB), 43), tmp, frictionConstraint2.angularComponentB, -frictionConstraint2.appliedImpulse);
          }
        }
      }
    }
    for (j = 0; j < numConstraints; ++j) {
      throwClassCastExceptionUnlessNull((checkIndex(constraints_offset + j, constraints.size) , constraints.array[constraints_offset + j]));
      null.nullMethod();
    }
    numConstraintPool = this$static.tmpSolverConstraintPool.size;
    numFrictionPool = this$static.tmpSolverFrictionConstraintPool.size;
    resize(this$static.orderTmpConstraintPool, numConstraintPool, 0);
    resize(this$static.orderFrictionConstraintPool, numFrictionPool, 0);
    for (i = 0; i < numConstraintPool; ++i) {
      $set_4(this$static.orderTmpConstraintPool, i, i);
    }
    for (i = 0; i < numFrictionPool; ++i) {
      $set_4(this$static.orderFrictionConstraintPool, i, i);
    }
    return 0;
  }
   finally {
  }
}

function getClass_88(){
  return Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_SequentialImpulseConstraintSolver_2_classLit;
}

function SequentialImpulseConstraintSolver(){
}

_ = SequentialImpulseConstraintSolver.prototype = new ConstraintSolver;
_.getClass$ = getClass_88;
_.typeId$ = 0;
_.btSeed2 = 0;
_.totalCpd = 0;
var MAX_CONTACT_SOLVER_TYPES_0;
function $SequentialImpulseConstraintSolver$1(this$static, this$0){
  this$static.this$0 = this$0;
  return this$static;
}

function getClass_89(){
  return Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_SequentialImpulseConstraintSolver$1_2_classLit;
}

function SequentialImpulseConstraintSolver$1(){
}

_ = SequentialImpulseConstraintSolver$1.prototype = new Object_0;
_.getClass$ = getClass_89;
_.typeId$ = 0;
_.this$0 = null;
function getClass_90(){
  return Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_SequentialImpulseConstraintSolver$OrderIndex_2_classLit;
}

function SequentialImpulseConstraintSolver$OrderIndex(){
}

_ = SequentialImpulseConstraintSolver$OrderIndex.prototype = new Object_0;
_.getClass$ = getClass_90;
_.typeId$ = 50;
function $SolverBody(this$static){
  this$static.angularVelocity = $Vector3f_2(new Vector3f);
  this$static.linearVelocity = $Vector3f_2(new Vector3f);
  this$static.centerOfMassPosition = $Vector3f_2(new Vector3f);
  this$static.pushVelocity = $Vector3f_2(new Vector3f);
  this$static.turnVelocity = $Vector3f_2(new Vector3f);
  return this$static;
}

function $internalApplyImpulse(this$static, linearComponent, angularComponent, impulseMagnitude){
  if (this$static.invMass != 0) {
    $scaleAdd(this$static.linearVelocity, impulseMagnitude, linearComponent, this$static.linearVelocity);
    $scaleAdd(this$static.angularVelocity, impulseMagnitude * this$static.angularFactor, angularComponent, this$static.angularVelocity);
  }
}

function $readVelocity(this$static){
  if (this$static.invMass != 0) {
    $getLinearVelocity(this$static.originalBody, this$static.linearVelocity);
    $getAngularVelocity(this$static.originalBody, this$static.angularVelocity);
  }
}

function $writebackVelocity(this$static){
  if (this$static.invMass != 0) {
    $set_9(this$static.originalBody.linearVelocity, this$static.linearVelocity);
    $set_9(this$static.originalBody.angularVelocity, this$static.angularVelocity);
  }
}

function getClass_91(){
  return Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_SolverBody_2_classLit;
}

function SolverBody(){
}

_ = SolverBody.prototype = new Object_0;
_.getClass$ = getClass_91;
_.typeId$ = 51;
_.angularFactor = 0;
_.invMass = 0;
_.originalBody = null;
function $SolverConstraint(this$static){
  this$static.relpos1CrossNormal = $Vector3f_2(new Vector3f);
  this$static.contactNormal = $Vector3f_2(new Vector3f);
  this$static.relpos2CrossNormal = $Vector3f_2(new Vector3f);
  this$static.angularComponentA = $Vector3f_2(new Vector3f);
  this$static.angularComponentB = $Vector3f_2(new Vector3f);
  return this$static;
}

function getClass_92(){
  return Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_SolverConstraint_2_classLit;
}

function SolverConstraint(){
}

_ = SolverConstraint.prototype = new Object_0;
_.getClass$ = getClass_92;
_.typeId$ = 52;
_.appliedImpulse = 0;
_.appliedPushImpulse = 0;
_.friction = 0;
_.frictionIndex = 0;
_.jacDiagABInv = 0;
_.originalContactPoint = null;
_.penetration = 0;
_.restitution = 0;
_.solverBodyIdA = 0;
_.solverBodyIdB = 0;
function $clinit_107(){
  $clinit_107 = nullMethod;
  SOLVER_CONTACT_1D = $SolverConstraintType(new SolverConstraintType, 'SOLVER_CONTACT_1D', 0);
  SOLVER_FRICTION_1D = $SolverConstraintType(new SolverConstraintType, 'SOLVER_FRICTION_1D', 1);
}

--></script>
<script><!--
function $SolverConstraintType(this$static, enum$name, enum$ordinal){
  $clinit_107();
  this$static.name_0 = enum$name;
  this$static.ordinal = enum$ordinal;
  return this$static;
}

function getClass_93(){
  return Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_SolverConstraintType_2_classLit;
}

function values_6(){
  $clinit_107();
  return initValues(_3Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_SolverConstraintType_2_classLit, 141, 51, [SOLVER_CONTACT_1D, SOLVER_FRICTION_1D]);
}

function SolverConstraintType(){
}

_ = SolverConstraintType.prototype = new Enum;
_.getClass$ = getClass_93;
_.typeId$ = 53;
var SOLVER_CONTACT_1D, SOLVER_FRICTION_1D;
function $clinit_108(){
  $clinit_108 = nullMethod;
  root = $CProfileNode(new CProfileNode);
}

var frameCounter = 0, root;
function $CProfileNode(this$static){
  this$static.totalCalls = 0;
  this$static.recursionCounter = 0;
  this$static.totalCalls = 0;
  ($clinit_1() , gProfileClock).startTime = fromDouble((new Date).getTime());
  return this$static;
}

function $call(this$static){
  ++this$static.totalCalls;
  this$static.recursionCounter++ == 0 && ($clinit_1() , $getTimeMicroseconds(gProfileClock));
}

function getClass_94(){
  return Lcom_bulletphysics_gwt_client_linearmath_CProfileNode_2_classLit;
}

function CProfileNode(){
}

_ = CProfileNode.prototype = new Object_0;
_.getClass$ = getClass_94;
_.typeId$ = 0;
_.recursionCounter = 0;
_.totalCalls = 0;
function $Clock(this$static){
  this$static.startTime = fromDouble((new Date).getTime());
  return this$static;
}

function $getTimeMicroseconds(this$static){
  return mul_0(sub(fromDouble((new Date).getTime()), this$static.startTime), P3e8_longLit);
}

function getClass_95(){
  return Lcom_bulletphysics_gwt_client_linearmath_Clock_2_classLit;
}

function Clock(){
}

_ = Clock.prototype = new Object_0;
_.getClass$ = getClass_95;
_.typeId$ = 0;
_.startTime = P0_longLit;
function $DefaultMotionState(this$static, startTrans){
  this$static.graphicsWorldTrans = $Transform(new Transform);
  this$static.centerOfMassOffset = $Transform(new Transform);
  this$static.startWorldTrans = $Transform(new Transform);
  $set_3(this$static.graphicsWorldTrans, startTrans);
  $setIdentity(this$static.centerOfMassOffset);
  $set_3(this$static.startWorldTrans, startTrans);
  return this$static;
}

function $getWorldTransform_0(this$static, out){
  $inverse_0(out, this$static.centerOfMassOffset);
  $mul(out, this$static.graphicsWorldTrans);
  return out;
}

function $setWorldTransform(this$static, centerOfMassWorldTrans){
  $set_3(this$static.graphicsWorldTrans, centerOfMassWorldTrans);
  $mul(this$static.graphicsWorldTrans, this$static.centerOfMassOffset);
}

function getClass_96(){
  return Lcom_bulletphysics_gwt_client_linearmath_DefaultMotionState_2_classLit;
}

function DefaultMotionState(){
}

_ = DefaultMotionState.prototype = new Object_0;
_.getClass$ = getClass_96;
_.typeId$ = 0;
function absolute(mat){
  mat.m00 = abs(mat.m00);
  mat.m01 = abs(mat.m01);
  mat.m02 = abs(mat.m02);
  mat.m10 = abs(mat.m10);
  mat.m11 = abs(mat.m11);
  mat.m12 = abs(mat.m12);
  mat.m20 = abs(mat.m20);
  mat.m21 = abs(mat.m21);
  mat.m22 = abs(mat.m22);
}

function getOpenGLSubMatrix(mat, m){
  m[0] = mat.m00;
  m[1] = mat.m10;
  m[2] = mat.m20;
  m[3] = 0;
  m[4] = mat.m01;
  m[5] = mat.m11;
  m[6] = mat.m21;
  m[7] = 0;
  m[8] = mat.m02;
  m[9] = mat.m12;
  m[10] = mat.m22;
  m[11] = 0;
}

function getRotation(mat, dest){
  var i, j, k, s, temp, trace;
  trace = mat.m00 + mat.m11 + mat.m22;
  temp = initDim(_3F_classLit, 149, -1, 4, 1);
  if (trace > 0) {
    s = Math.sqrt(trace + 1);
    temp[3] = s * 0.5;
    s = 0.5 / s;
    temp[0] = (mat.m21 - mat.m12) * s;
    temp[1] = (mat.m02 - mat.m20) * s;
    temp[2] = (mat.m10 - mat.m01) * s;
  }
   else {
    i = mat.m00 < mat.m11?mat.m11 < mat.m22?2:1:mat.m00 < mat.m22?2:0;
    j = (i + 1) % 3;
    k = (i + 2) % 3;
    s = Math.sqrt($getElement_0(mat, i, i) - $getElement_0(mat, j, j) - $getElement_0(mat, k, k) + 1);
    temp[i] = s * 0.5;
    s = 0.5 / s;
    temp[3] = ($getElement_0(mat, k, j) - $getElement_0(mat, j, k)) * s;
    temp[j] = ($getElement_0(mat, j, i) + $getElement_0(mat, i, j)) * s;
    temp[k] = ($getElement_0(mat, k, i) + $getElement_0(mat, i, k)) * s;
  }
  dest.x = temp[0];
  dest.y = temp[1];
  dest.z = temp[2];
  dest.w = temp[3];
}

function scale(dest, mat, s){
  dest.m00 = mat.m00 * s.x;
  dest.m01 = mat.m01 * s.y;
  dest.m02 = mat.m02 * s.z;
  dest.m10 = mat.m10 * s.x;
  dest.m11 = mat.m11 * s.y;
  dest.m12 = mat.m12 * s.z;
  dest.m20 = mat.m20 * s.x;
  dest.m21 = mat.m21 * s.y;
  dest.m22 = mat.m22 * s.z;
}

function setRotation(dest, q){
  var d, s, wx, wy, wz, xs, xx, xy, xz, ys, yy, yz, zs, zz;
  d = q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w;
  s = 2 / d;
  xs = q.x * s;
  ys = q.y * s;
  zs = q.z * s;
  wx = q.w * xs;
  wy = q.w * ys;
  wz = q.w * zs;
  xx = q.x * xs;
  xy = q.x * ys;
  xz = q.x * zs;
  yy = q.y * ys;
  yz = q.y * zs;
  zz = q.z * zs;
  dest.m00 = 1 - (yy + zz);
  dest.m01 = xy - wz;
  dest.m02 = xz + wy;
  dest.m10 = xy + wz;
  dest.m11 = 1 - (xx + zz);
  dest.m12 = yz - wx;
  dest.m20 = xz - wy;
  dest.m21 = yz + wx;
  dest.m22 = 1 - (xx + yy);
}

function transposeTransform(dest, vec, mat){
  var x, y, z;
  x = mat.m00 * vec.x + mat.m10 * vec.y + mat.m20 * vec.z;
  y = mat.m01 * vec.x + mat.m11 * vec.y + mat.m21 * vec.z;
  z = mat.m02 * vec.x + mat.m12 * vec.y + mat.m22 * vec.z;
  dest.x = x;
  dest.y = y;
  dest.z = z;
}

function GEN_clamped(a, lb, ub){
  return a < lb?lb:ub < a?ub:a;
}

function quickSort(list, comparator){
  list.size > 1 && quickSortInternal(list, comparator, 0, list.size - 1);
}

function quickSortInternal(list, comparator, lo, hi){
  var i, j, x, temp;
  i = lo;
  j = hi;
  x = list.get(~~((lo + hi) / 2));
  do {
    while (comparator.compare(list.get(i), x) < 0)
      ++i;
    while (comparator.compare(x, list.get(j)) < 0)
      --j;
    if (i <= j) {
      temp = list.get(i);
      list.set(i, list.get(j));
      list.set(j, temp);
      ++i;
      --j;
    }
  }
   while (i <= j);
  lo < j && quickSortInternal(list, comparator, lo, j);
  i < hi && quickSortInternal(list, comparator, i, hi);
}

function resize(list, size, value){
  var newArray_0;
  while (list.size < size) {
    list.size == list.array.length && (newArray_0 = initDim(_3I_classLit, 150, -1, list.array.length << 1, 1) , arraycopy(list.array, 0, newArray_0, 0, list.array.length) , list.array = newArray_0 , undefined);
    list.array[list.size++] = value;
  }
  while (list.size > size) {
    $remove(list, list.size - 1);
  }
}

function resize_0(list, size, valueCls){
  while (list.size < size) {
    $add_7(list, valueCls?new UnionFind$Element:null);
  }
  while (list.size > size) {
    $remove_6(list, list.size - 1);
  }
}

function fsel(a, b, c){
  return a >= 0?b:c;
}

function $$init_48(this$static){
  this$static.basis = $Matrix3f_0(new Matrix3f);
  this$static.origin = $Vector3f_2(new Vector3f);
}

function $Transform(this$static){
  $$init_48(this$static);
  return this$static;
}

function $Transform_0(this$static, tr){
  $$init_48(this$static);
  $set_6(this$static.basis, tr.basis);
  $set_9(this$static.origin, tr.origin);
  return this$static;
}

function $getRotation(this$static, out){
  getRotation(this$static.basis, out);
  return out;
}

function $invXform(this$static, inVec, out){
  var mat;
  $sub(out, inVec, this$static.origin);
  mat = $Matrix3f(new Matrix3f, this$static.basis);
  $transpose(mat);
  $transform_0(mat, out);
}

function $inverse(this$static){
  $transpose(this$static.basis);
  $scale_0(this$static.origin, -1);
  $transform_0(this$static.basis, this$static.origin);
}

function $inverse_0(this$static, tr){
  $set_6(this$static.basis, tr.basis);
  $set_9(this$static.origin, tr.origin);
  $inverse(this$static);
}

function $mul(this$static, tr){
  var vec;
  vec = $Vector3f_1(new Vector3f, tr.origin);
  $transform_0(this$static.basis, vec);
  $add_2(vec, this$static.origin);
  $mul_1(this$static.basis, tr.basis);
  $set_9(this$static.origin, vec);
}

function $mul_0(this$static, tr1, tr2){
  var vec;
  vec = $Vector3f_1(new Vector3f, tr2.origin);
  $transform_0(tr1.basis, vec);
  $add_2(vec, tr1.origin);
  $mul_2(this$static.basis, tr1.basis, tr2.basis);
  $set_9(this$static.origin, vec);
}

function $set_3(this$static, tr){
  $set_6(this$static.basis, tr.basis);
  $set_9(this$static.origin, tr.origin);
}

function $setIdentity(this$static){
  $setIdentity_0(this$static.basis);
  $set_8(this$static.origin, 0, 0, 0);
}

function $transform(this$static, v){
  $transform_0(this$static.basis, v);
  $add_2(v, this$static.origin);
}

function equals_1(obj){
  var tr;
  if (obj == null || !(obj != null && canCast(obj.typeId$, 44)))
    return false;
  tr = dynamicCast(obj, 44);
  return $equals_1(this.basis, tr.basis) && $equals_2(this.origin, tr.origin);
}

function getClass_97(){
  return Lcom_bulletphysics_gwt_client_linearmath_Transform_2_classLit;
}

function hashCode_2(){
  var hash;
  hash = 3;
  hash = 41 * hash + $hashCode_1(this.basis);
  hash = 41 * hash + $hashCode_2(this.origin);
  return hash;
}

function Transform(){
}

_ = Transform.prototype = new Object_0;
_.equals$ = equals_1;
_.getClass$ = getClass_97;
_.hashCode$ = hashCode_2;
_.typeId$ = 54;
function calculateVelocity(transform0, transform1, timeStep, linVel, angVel){
  var angle, axis, dmat, dorn, len, tmp, co_x, co_y, co_z, det, m00, m01, m02, m10, m11, m12, m20, m21, m22, s;
  $sub(linVel, transform1.origin, transform0.origin);
  linVel.x *= 1 / timeStep;
  linVel.y *= 1 / timeStep;
  linVel.z *= 1 / timeStep;
  axis = $Vector3f_2(new Vector3f);
  angle = initDim(_3F_classLit, 149, -1, 1, 1);
  tmp = $Matrix3f_0(new Matrix3f);
  $set_6(tmp, transform0.basis);
  co_x = $getElement_0(tmp, 1, 1) * $getElement_0(tmp, 2, 2) - $getElement_0(tmp, 1, 2) * $getElement_0(tmp, 2, 1);
  co_y = $getElement_0(tmp, 1, 2) * $getElement_0(tmp, 2, 0) - $getElement_0(tmp, 1, 0) * $getElement_0(tmp, 2, 2);
  co_z = $getElement_0(tmp, 1, 0) * $getElement_0(tmp, 2, 1) - $getElement_0(tmp, 1, 1) * $getElement_0(tmp, 2, 0);
  det = tmp.m00 * co_x + tmp.m01 * co_y + tmp.m02 * co_z;
  s = 1 / det;
  m00 = co_x * s;
  m01 = ($getElement_0(tmp, 0, 2) * $getElement_0(tmp, 2, 1) - $getElement_0(tmp, 0, 1) * $getElement_0(tmp, 2, 2)) * s;
  m02 = ($getElement_0(tmp, 0, 1) * $getElement_0(tmp, 1, 2) - $getElement_0(tmp, 0, 2) * $getElement_0(tmp, 1, 1)) * s;
  m10 = co_y * s;
  m11 = ($getElement_0(tmp, 0, 0) * $getElement_0(tmp, 2, 2) - $getElement_0(tmp, 0, 2) * $getElement_0(tmp, 2, 0)) * s;
  m12 = ($getElement_0(tmp, 0, 2) * $getElement_0(tmp, 1, 0) - $getElement_0(tmp, 0, 0) * $getElement_0(tmp, 1, 2)) * s;
  m20 = co_z * s;
  m21 = ($getElement_0(tmp, 0, 1) * $getElement_0(tmp, 2, 0) - $getElement_0(tmp, 0, 0) * $getElement_0(tmp, 2, 1)) * s;
  m22 = ($getElement_0(tmp, 0, 0) * $getElement_0(tmp, 1, 1) - $getElement_0(tmp, 0, 1) * $getElement_0(tmp, 1, 0)) * s;
  tmp.m00 = m00;
  tmp.m01 = m01;
  tmp.m02 = m02;
  tmp.m10 = m10;
  tmp.m11 = m11;
  tmp.m12 = m12;
  tmp.m20 = m20;
  tmp.m21 = m21;
  tmp.m22 = m22;
  dmat = $Matrix3f_0(new Matrix3f);
  $mul_2(dmat, transform1.basis, tmp);
  dorn = $Quat4f(new Quat4f);
  getRotation(dmat, dorn);
  $normalize(dorn);
  angle[0] = 2 * Math.acos(dorn.w);
  $set_8(axis, dorn.x, dorn.y, dorn.z);
  len = axis.x * axis.x + axis.y * axis.y + axis.z * axis.z;
  len < 1.4210854715202004E-14?(axis.x = 1 , axis.y = 0 , axis.z = 0 , undefined):$scale_0(axis, 1 / Math.sqrt(len));
  angVel.x = angle[0] / timeStep * axis.x;
  angVel.y = angle[0] / timeStep * axis.y;
  angVel.z = angle[0] / timeStep * axis.z;
}

function integrateTransform(curTrans, linvel, angvel, timeStep, predictedTransform){
  var axis, dorn, fAngle, orn0, predictedOrn;
  $scaleAdd(predictedTransform.origin, timeStep, linvel, curTrans.origin);
  axis = $Vector3f_2(new Vector3f);
  fAngle = Math.sqrt(angvel.x * angvel.x + angvel.y * angvel.y + angvel.z * angvel.z);
  fAngle * timeStep > 0.7853981852531433 && (fAngle = 0.7853981852531433 / timeStep);
  fAngle < 0.0010000000474974513?(axis.x = (0.5 * timeStep - timeStep * timeStep * timeStep * 0.02083333395421505 * fAngle * fAngle) * angvel.x , axis.y = (0.5 * timeStep - timeStep * timeStep * timeStep * 0.02083333395421505 * fAngle * fAngle) * angvel.y , axis.z = (0.5 * timeStep - timeStep * timeStep * timeStep * 0.02083333395421505 * fAngle * fAngle) * angvel.z , undefined):$scale(axis, Math.sin(0.5 * fAngle * timeStep) / fAngle, angvel);
  dorn = $Quat4f(new Quat4f);
  $set_7(dorn, axis.x, axis.y, axis.z, Math.cos(fAngle * timeStep * 0.5));
  orn0 = $getRotation(curTrans, $Quat4f(new Quat4f));
  predictedOrn = $Quat4f(new Quat4f);
  $mul_3(predictedOrn, dorn, orn0);
  $normalize(predictedOrn);
  setRotation(predictedTransform.basis, predictedOrn);
}

function planeSpace1(n, p, q){
  var a, k;
  if (abs(n.z) > 0.7071067690849304) {
    a = n.y * n.y + n.z * n.z;
    k = 1 / Math.sqrt(a);
    $set_8(p, 0, -n.z * k, n.y * k);
    $set_8(q, a * k, -n.x * p.z, n.x * p.y);
  }
   else {
    a = n.x * n.x + n.y * n.y;
    k = 1 / Math.sqrt(a);
    $set_8(p, -n.y * k, n.x * k, 0);
    $set_8(q, -n.z * p.y, n.z * p.x, a * k);
  }
}

function add(dest, v1, v2, v3){
  dest.x = v1.x + v2.x + v3.x;
  dest.y = v1.y + v2.y + v3.y;
  dest.z = v1.z + v2.z + v3.z;
}

function add_0(dest, v1, v2, v3, v4){
  dest.x = v1.x + v2.x + v3.x + v4.x;
  dest.y = v1.y + v2.y + v3.y + v4.y;
  dest.z = v1.z + v2.z + v3.z + v4.z;
}

function getCoord(vec, num){
  switch (num) {
    case 0:
      return vec.x;
    case 1:
      return vec.y;
    case 2:
      return vec.z;
    default:throw $RuntimeException(new RuntimeException);
  }
}

function maxAxis(v){
  var maxIndex, maxVal;
  maxIndex = -1;
  maxVal = -1.0000000150474662E30;
  if (v.x > maxVal) {
    maxIndex = 0;
    maxVal = v.x;
  }
  if (v.y > maxVal) {
    maxIndex = 1;
    maxVal = v.y;
  }
  if (v.z > maxVal) {
    maxIndex = 2;
    maxVal = v.z;
  }
  return maxIndex;
}

function maxAxis4(v){
  var maxIndex, maxVal;
  maxIndex = -1;
  maxVal = -1.0000000150474662E30;
  if (v.x > maxVal) {
    maxIndex = 0;
    maxVal = v.x;
  }
  if (v.y > maxVal) {
    maxIndex = 1;
    maxVal = v.y;
  }
  if (v.z > maxVal) {
    maxIndex = 2;
    maxVal = v.z;
  }
  if (v.w > maxVal) {
    maxIndex = 3;
    maxVal = v.w;
  }
  return maxIndex;
}

function mul(dest, v1, v2){
  dest.x = v1.x * v2.x;
  dest.y = v1.y * v2.y;
  dest.z = v1.z * v2.z;
}

function setCoord(vec, num, value){
  switch (num) {
    case 0:
      vec.x = value;
      break;
    case 1:
      vec.y = value;
      break;
    case 2:
      vec.z = value;
      break;
    default:throw $RuntimeException(new RuntimeException);
  }
}

function setInterpolate3(dest, v0, v1, rt){
  var s;
  s = 1 - rt;
  dest.x = s * v0.x + rt * v1.x;
  dest.y = s * v0.y + rt * v1.y;
  dest.z = s * v0.z + rt * v1.z;
}

function setMax(a, b){
  a.x = max_0(a.x, b.x);
  a.y = max_0(a.y, b.y);
  a.z = max_0(a.z, b.z);
}

function setMin(a, b){
  a.x = min_0(a.x, b.x);
  a.y = min_0(a.y, b.y);
  a.z = min_0(a.z, b.z);
}

function $clinit_120(){
  $clinit_120 = nullMethod;
  floatComparator = new ArrayPool$1;
  intComparator = new ArrayPool$2;
  objectComparator = new ArrayPool$3;
  map_0 = $HashMap(new HashMap);
}

function $ArrayPool(this$static, componentType){
  $clinit_120();
  this$static.list = $ArrayList(new ArrayList);
  this$static.key = new ArrayPool$IntValue;
  this$static.componentType = componentType;
  if (componentType == F_classLit) {
    this$static.comparator = floatComparator;
  }
   else if (componentType == I_classLit) {
    this$static.comparator = intComparator;
  }
   else if ((componentType.modifiers & 1) != 0) {
    throw $UnsupportedOperationException_0(new UnsupportedOperationException, 'unsupported type ' + componentType);
  }
   else {
    this$static.comparator = objectComparator;
  }
  return this$static;
}

function $create(this$static, length_0){
  if (this$static.componentType == I_classLit) {
    return initDim(_3I_classLit, 150, -1, length_0, 1);
  }
  if (this$static.componentType == F_classLit) {
    return initDim(_3F_classLit, 149, -1, length_0, 1);
  }
  throw $RuntimeException_0(new RuntimeException, 'unsupported class type');
}

function $getFixed(this$static, length_0){
  var index;
  this$static.key.value_0 = length_0;
  index = binarySearch(this$static.list, this$static.key, this$static.comparator);
  if (index < 0) {
    return $create(this$static, length_0);
  }
  return $remove_6(this$static.list, index);
}

function $release(this$static, array){
  var i, index, objArray;
  index = binarySearch(this$static.list, array, this$static.comparator);
  index < 0 && (index = -index - 1);
  $add_8(this$static.list, index, array);
  if (this$static.comparator == objectComparator) {
    objArray = dynamicCast(array, 11);
    for (i = 0; i < objArray.length; ++i) {
      setCheck(objArray, i, null);
    }
  }
}

function get(cls){
  $clinit_120();
  var pool;
  pool = dynamicCast($get_5(map_0, cls), 61);
  if (!pool) {
    pool = $ArrayPool(new ArrayPool, cls);
    $put(map_0, cls, pool);
  }
  return pool;
}

function getClass_98(){
  return Lcom_bulletphysics_gwt_client_util_ArrayPool_2_classLit;
}

function ArrayPool(){
}

_ = ArrayPool.prototype = new Object_0;
_.getClass$ = getClass_98;
_.typeId$ = 55;
_.comparator = null;
_.componentType = null;
var floatComparator, intComparator, map_0, objectComparator;
function compare_3(o1, o2){
  var len1, len2;
  len1 = o1 != null && canCast(o1.typeId$, 62)?dynamicCast(o1, 62).value_0:dynamicCast(o1, 29).length;
  len2 = o2 != null && canCast(o2.typeId$, 62)?dynamicCast(o2, 62).value_0:dynamicCast(o2, 29).length;
  return len1 > len2?1:len1 < len2?-1:0;
}

function getClass_99(){
  return Lcom_bulletphysics_gwt_client_util_ArrayPool$1_2_classLit;
}

function ArrayPool$1(){
}

_ = ArrayPool$1.prototype = new Object_0;
_.compare = compare_3;
_.getClass$ = getClass_99;
_.typeId$ = 0;
function compare_4(o1, o2){
  var len1, len2;
  len1 = o1 != null && canCast(o1.typeId$, 62)?dynamicCast(o1, 62).value_0:dynamicCast(o1, 8).length;
  len2 = o2 != null && canCast(o2.typeId$, 62)?dynamicCast(o2, 62).value_0:dynamicCast(o2, 8).length;
  return len1 > len2?1:len1 < len2?-1:0;
}

function getClass_100(){
  return Lcom_bulletphysics_gwt_client_util_ArrayPool$2_2_classLit;
}

function ArrayPool$2(){
}

_ = ArrayPool$2.prototype = new Object_0;
_.compare = compare_4;
_.getClass$ = getClass_100;
_.typeId$ = 0;
function compare_5(o1, o2){
  var len1, len2;
  len1 = o1 != null && canCast(o1.typeId$, 62)?dynamicCast(o1, 62).value_0:dynamicCast(o1, 11).length;
  len2 = o2 != null && canCast(o2.typeId$, 62)?dynamicCast(o2, 62).value_0:dynamicCast(o2, 11).length;
  return len1 > len2?1:len1 < len2?-1:0;
}

function getClass_101(){
  return Lcom_bulletphysics_gwt_client_util_ArrayPool$3_2_classLit;
}

function ArrayPool$3(){
}

_ = ArrayPool$3.prototype = new Object_0;
_.compare = compare_5;
_.getClass$ = getClass_101;
_.typeId$ = 0;
function getClass_102(){
  return Lcom_bulletphysics_gwt_client_util_ArrayPool$IntValue_2_classLit;
}

function ArrayPool$IntValue(){
}

_ = ArrayPool$IntValue.prototype = new Object_0;
_.getClass$ = getClass_102;
_.typeId$ = 56;
_.value_0 = 0;
function $clinit_125(){
  $clinit_125 = nullMethod;
  compoundCollisionAlgorithmFactory = new FactoriesHelper$1;
  persistentManifoldFactory = new FactoriesHelper$2;
  broadphasePairFactory = new FactoriesHelper$3;
  convexConcaveCollisionAlgorithmFactory = new FactoriesHelper$4;
  closestPointInputFactory = new FactoriesHelper$5;
  convexConvexAlgorithmFactory = new FactoriesHelper$6;
  convexPlaneCollisionAlgorithmFactory = new FactoriesHelper$7;
  manifoldPointFactory = new FactoriesHelper$8;
  sphereSphereCollisionAlgorithmFactory = new FactoriesHelper$9;
  mkvFactory = new FactoriesHelper$10;
  heFactory = new FactoriesHelper$11;
  faceFactory = new FactoriesHelper$12;
  subSimplexClosestResultFactory = new FactoriesHelper$13;
  jacobianEntryFactory = new FactoriesHelper$15;
  solverBodyFactory = new FactoriesHelper$16;
  solverConstraintFactory = new FactoriesHelper$17;
}

var broadphasePairFactory, closestPointInputFactory, compoundCollisionAlgorithmFactory, convexConcaveCollisionAlgorithmFactory, convexConvexAlgorithmFactory, convexPlaneCollisionAlgorithmFactory, faceFactory, heFactory, jacobianEntryFactory, manifoldPointFactory, mkvFactory, persistentManifoldFactory, solverBodyFactory, solverConstraintFactory, sphereSphereCollisionAlgorithmFactory, subSimplexClosestResultFactory;
function create(){
  return $CompoundCollisionAlgorithm(new CompoundCollisionAlgorithm);
}

function getClass_103(){
  return Lcom_bulletphysics_gwt_client_util_FactoriesHelper$1_2_classLit;
}

function FactoriesHelper$1(){
}

_ = FactoriesHelper$1.prototype = new Object_0;
_.create = create;
_.getClass$ = getClass_103;
_.typeId$ = 0;
function create_0(){
  return $GjkEpaSolver$Mkv(new GjkEpaSolver$Mkv);
}

function getClass_104(){
  return Lcom_bulletphysics_gwt_client_util_FactoriesHelper$10_2_classLit;
}

function FactoriesHelper$10(){
}

_ = FactoriesHelper$10.prototype = new Object_0;
_.create = create_0;
_.getClass$ = getClass_104;
_.typeId$ = 0;
function create_1(){
  return $GjkEpaSolver$He(new GjkEpaSolver$He);
}

function getClass_105(){
  return Lcom_bulletphysics_gwt_client_util_FactoriesHelper$11_2_classLit;
}

function FactoriesHelper$11(){
}

_ = FactoriesHelper$11.prototype = new Object_0;
_.create = create_1;
_.getClass$ = getClass_105;
_.typeId$ = 0;
function create_2(){
  return $GjkEpaSolver$Face(new GjkEpaSolver$Face);
}

function getClass_106(){
  return Lcom_bulletphysics_gwt_client_util_FactoriesHelper$12_2_classLit;
}

function FactoriesHelper$12(){
}

_ = FactoriesHelper$12.prototype = new Object_0;
_.create = create_2;
_.getClass$ = getClass_106;
_.typeId$ = 0;
function create_3(){
  return $VoronoiSimplexSolver$SubSimplexClosestResult(new VoronoiSimplexSolver$SubSimplexClosestResult);
}

function getClass_107(){
  return Lcom_bulletphysics_gwt_client_util_FactoriesHelper$13_2_classLit;
}

function FactoriesHelper$13(){
}

_ = FactoriesHelper$13.prototype = new Object_0;
_.create = create_3;
_.getClass$ = getClass_107;
_.typeId$ = 0;
function create_4(){
  return $JacobianEntry(new JacobianEntry);
}

function getClass_108(){
  return Lcom_bulletphysics_gwt_client_util_FactoriesHelper$15_2_classLit;
}

function FactoriesHelper$15(){
}

_ = FactoriesHelper$15.prototype = new Object_0;
_.create = create_4;
_.getClass$ = getClass_108;
_.typeId$ = 0;
function create_5(){
  return $SolverBody(new SolverBody);
}

function getClass_109(){
  return Lcom_bulletphysics_gwt_client_util_FactoriesHelper$16_2_classLit;
}

function FactoriesHelper$16(){
}

_ = FactoriesHelper$16.prototype = new Object_0;
_.create = create_5;
_.getClass$ = getClass_109;
_.typeId$ = 0;
function create_6(){
  return $SolverConstraint(new SolverConstraint);
}

function getClass_110(){
  return Lcom_bulletphysics_gwt_client_util_FactoriesHelper$17_2_classLit;
}

function FactoriesHelper$17(){
}

_ = FactoriesHelper$17.prototype = new Object_0;
_.create = create_6;
_.getClass$ = getClass_110;
_.typeId$ = 0;
function create_7(){
  return $PersistentManifold(new PersistentManifold);
}

function getClass_111(){
  return Lcom_bulletphysics_gwt_client_util_FactoriesHelper$2_2_classLit;
}

function FactoriesHelper$2(){
}

_ = FactoriesHelper$2.prototype = new Object_0;
_.create = create_7;
_.getClass$ = getClass_111;
_.typeId$ = 0;
function create_8(){
  return new BroadphasePair;
}

function getClass_112(){
  return Lcom_bulletphysics_gwt_client_util_FactoriesHelper$3_2_classLit;
}

function FactoriesHelper$3(){
}

_ = FactoriesHelper$3.prototype = new Object_0;
_.create = create_8;
_.getClass$ = getClass_112;
_.typeId$ = 0;
function create_9(){
  return new ConvexConcaveCollisionAlgorithm;
}

function getClass_113(){
  return Lcom_bulletphysics_gwt_client_util_FactoriesHelper$4_2_classLit;
}

function FactoriesHelper$4(){
}

_ = FactoriesHelper$4.prototype = new Object_0;
_.create = create_9;
_.getClass$ = getClass_113;
_.typeId$ = 0;
function create_10(){
  return $DiscreteCollisionDetectorInterface$ClosestPointInput(new DiscreteCollisionDetectorInterface$ClosestPointInput);
}

function getClass_114(){
  return Lcom_bulletphysics_gwt_client_util_FactoriesHelper$5_2_classLit;
}

function FactoriesHelper$5(){
}

_ = FactoriesHelper$5.prototype = new Object_0;
_.create = create_10;
_.getClass$ = getClass_114;
_.typeId$ = 0;
function create_11(){
  return $ConvexConvexAlgorithm(new ConvexConvexAlgorithm);
}

function getClass_115(){
  return Lcom_bulletphysics_gwt_client_util_FactoriesHelper$6_2_classLit;
}

function FactoriesHelper$6(){
}

_ = FactoriesHelper$6.prototype = new Object_0;
_.create = create_11;
_.getClass$ = getClass_115;
_.typeId$ = 0;
function create_12(){
  return new ConvexPlaneCollisionAlgorithm;
}

function getClass_116(){
  return Lcom_bulletphysics_gwt_client_util_FactoriesHelper$7_2_classLit;
}

function FactoriesHelper$7(){
}

_ = FactoriesHelper$7.prototype = new Object_0;
_.create = create_12;
_.getClass$ = getClass_116;
_.typeId$ = 0;
function create_13(){
  return $ManifoldPoint(new ManifoldPoint);
}

function getClass_117(){
  return Lcom_bulletphysics_gwt_client_util_FactoriesHelper$8_2_classLit;
}

function FactoriesHelper$8(){
}

_ = FactoriesHelper$8.prototype = new Object_0;
_.create = create_13;
_.getClass$ = getClass_117;
_.typeId$ = 0;
function create_14(){
  return new SphereSphereCollisionAlgorithm;
}

function getClass_118(){
  return Lcom_bulletphysics_gwt_client_util_FactoriesHelper$9_2_classLit;
}

function FactoriesHelper$9(){
}

_ = FactoriesHelper$9.prototype = new Object_0;
_.create = create_14;
_.getClass$ = getClass_118;
_.typeId$ = 0;
function $IntArrayList(this$static){
  this$static.array = initDim(_3I_classLit, 150, -1, 16, 1);
  return this$static;
}

function $get(this$static, index){
  if (index >= this$static.size)
    throw $IndexOutOfBoundsException(new IndexOutOfBoundsException);
  return this$static.array[index];
}

function $remove(this$static, index){
  var old;
  if (index >= this$static.size)
    throw $IndexOutOfBoundsException(new IndexOutOfBoundsException);
  old = this$static.array[index];
  arraycopy(this$static.array, index + 1, this$static.array, index, this$static.size - index - 1);
  --this$static.size;
  return old;
}

function $set_4(this$static, index, value){
  if (index >= this$static.size)
    throw $IndexOutOfBoundsException(new IndexOutOfBoundsException);
  this$static.array[index] = value;
}

function getClass_119(){
  return Lcom_bulletphysics_gwt_client_util_IntArrayList_2_classLit;
}

function IntArrayList(){
}

_ = IntArrayList.prototype = new Object_0;
_.getClass$ = getClass_119;
_.typeId$ = 0;
_.size = 0;
function $advanceToFind(iter, o){
  var t;
  while (iter.hasNext()) {
    t = iter.next_0();
    if (o == null?t == null:o.typeMarker$ == nullMethod || o.typeId$ == 2?o.equals$(t):(o == null?null:o) === (t == null?null:t)) {
      return iter;
    }
  }
  return null;
}

function $toArray(this$static, a){
  var i, it, result, size, outerIter, entry;
  size = this$static.map.size;
  a.length < size && (a = createFrom(a, size));
  result = a;
  it = (outerIter = $AbstractHashMap$EntrySetIterator(new AbstractHashMap$EntrySetIterator, $keySet(this$static.map).val$entrySet.this$0) , $AbstractMap$1$1(new AbstractMap$1$1, outerIter));
  for (i = 0; i < size; ++i) {
    setCheck(result, i, (entry = dynamicCast($next_3(it.val$outerIter.iter), 78) , entry.getKey()));
  }
  a.length > size && setCheck(a, size, null);
  return a;
}

function $toString(this$static){
  var comma, iter, sb;
  sb = $StringBuffer(new StringBuffer);
  comma = null;
  sb.impl.string += '[';
  iter = this$static.iterator_0();
  while (iter.hasNext()) {
    comma != null?(sb.impl.string += comma , undefined):(comma = ', ');
    $append_0(sb, '' + iter.next_0());
  }
  sb.impl.string += ']';
  return sb.impl.string;
}

function add_1(o){
  throw $UnsupportedOperationException_0(new UnsupportedOperationException, 'Add not supported on this collection');
}

function contains(o){
  var iter;
  iter = $advanceToFind(this.iterator_0(), o);
  return !!iter;
}

function getClass_120(){
  return Ljava_util_AbstractCollection_2_classLit;
}

function toString_2(){
  return $toString(this);
}

function AbstractCollection(){
}

_ = AbstractCollection.prototype = new Object_0;
_.add = add_1;
_.contains = contains;
_.getClass$ = getClass_120;
_.toString$ = toString_2;
_.typeId$ = 0;
function $equals_0(this$static, o){
  var elem, elemOther, iter, iterOther, other;
  if ((o == null?null:o) === (this$static == null?null:this$static)) {
    return true;
  }
  if (!(o != null && canCast(o.typeId$, 79))) {
    return false;
  }
  other = dynamicCast(o, 79);
  if (this$static.size_0() != other.size_0()) {
    return false;
  }
  iter = $AbstractList$IteratorImpl(new AbstractList$IteratorImpl, this$static);
  iterOther = other.iterator_0();
  while (iter.i < iter.this$0.size_0()) {
    elem = $next_3(iter);
    elemOther = iterOther.next_0();
    if (!(elem == null?elemOther == null:elem.typeMarker$ == nullMethod || elem.typeId$ == 2?elem.equals$(elemOther):(elem == null?null:elem) === (elemOther == null?null:elemOther))) {
      return false;
    }
  }
  return true;
}

function $hashCode_0(this$static){
  var iter, k, obj;
  k = 1;
  iter = $AbstractList$IteratorImpl(new AbstractList$IteratorImpl, this$static);
  while (iter.i < iter.this$0.size_0()) {
    obj = $next_3(iter);
    k = 31 * k + (obj == null?0:obj.typeMarker$ == nullMethod || obj.typeId$ == 2?obj.hashCode$():obj.$H || (obj.$H = ++sNextHashId));
    k = ~~k;
  }
  return k;
}

function add_2(obj){
  this.add_0(this.size_0(), obj);
  return true;
}

--></script>
<script><!--
function add_3(index, element){
  throw $UnsupportedOperationException_0(new UnsupportedOperationException, 'Add not supported on this list');
}

function checkIndex(index, size){
  (index < 0 || index >= size) && indexOutOfBounds(index, size);
}

function equals_2(o){
  return $equals_0(this, o);
}

function getClass_121(){
  return Ljava_util_AbstractList_2_classLit;
}

function hashCode_3(){
  return $hashCode_0(this);
}

function indexOutOfBounds(index, size){
  throw $IndexOutOfBoundsException_0(new IndexOutOfBoundsException, 'Index: ' + index + ', Size: ' + size);
}

function iterator(){
  return $AbstractList$IteratorImpl(new AbstractList$IteratorImpl, this);
}

function set(index, o){
  throw $UnsupportedOperationException_0(new UnsupportedOperationException, 'Set not supported on this list');
}

function AbstractList(){
}

_ = AbstractList.prototype = new AbstractCollection;
_.add = add_2;
_.add_0 = add_3;
_.equals$ = equals_2;
_.getClass$ = getClass_121;
_.hashCode$ = hashCode_3;
_.iterator_0 = iterator;
_.set = set;
_.typeId$ = 57;
function $ObjectArrayList(this$static){
  this$static.array = initDim(_3Ljava_lang_Object_2_classLit, 157, 0, 16, 0);
  return this$static;
}

function $add_0(this$static, value){
  var newArray;
  this$static.size == this$static.array.length && (newArray = initDim(_3Ljava_lang_Object_2_classLit, 157, 0, this$static.array.length << 1, 0) , arraycopy(this$static.array, 0, newArray, 0, this$static.array.length) , this$static.array = newArray , undefined);
  setCheck(this$static.array, this$static.size++, value);
  return true;
}

function $get_0(this$static, index){
  if (index >= this$static.size)
    throw $IndexOutOfBoundsException(new IndexOutOfBoundsException);
  return this$static.array[index];
}

function $indexOf(this$static, o){
  var i;
  for (i = 0; i < this$static.size; ++i) {
    if (!o?this$static.array[i] == null:(o == null?null:o) === maskUndefined(this$static.array[i])) {
      return i;
    }
  }
  return -1;
}

function $remove_0(this$static, index){
  var old;
  if (index >= this$static.size)
    throw $IndexOutOfBoundsException(new IndexOutOfBoundsException);
  old = this$static.array[index];
  arraycopy(this$static.array, index + 1, this$static.array, index, this$static.size - index - 1);
  --this$static.size;
  return old;
}

function $set_5(this$static, index, value){
  var old;
  if (index >= this$static.size)
    throw $IndexOutOfBoundsException(new IndexOutOfBoundsException);
  old = this$static.array[index];
  setCheck(this$static.array, index, value);
  return old;
}

function add_4(value){
  return $add_0(this, value);
}

function get_0(index){
  return $get_0(this, index);
}

function getClass_122(){
  return Lcom_bulletphysics_gwt_client_util_ObjectArrayList_2_classLit;
}

function set_0(index, value){
  return $set_5(this, index, value);
}

function size_0(){
  return this.size;
}

function ObjectArrayList(){
}

_ = ObjectArrayList.prototype = new AbstractList;
_.add = add_4;
_.get = get_0;
_.getClass$ = getClass_122;
_.set = set_0;
_.size_0 = size_0;
_.typeId$ = 58;
_.array = null;
_.size = 0;
function $clinit_147(){
  $clinit_147 = nullMethod;
  map_1 = $HashMap(new HashMap);
}

function $ObjectPool(this$static, factory){
  $clinit_147();
  this$static.list = $ArrayList(new ArrayList);
  this$static.factory = factory;
  return this$static;
}

function $get_1(this$static){
  if (this$static.list.size > 0) {
    return $remove_6(this$static.list, this$static.list.size - 1);
  }
   else {
    return this$static.factory.create();
  }
}

function get_1(cls, factory){
  $clinit_147();
  var pool;
  pool = dynamicCast($get_5(map_1, cls), 63);
  if (!pool) {
    pool = $ObjectPool(new ObjectPool, factory);
    $put(map_1, cls, pool);
  }
  return pool;
}

function getClass_123(){
  return Lcom_bulletphysics_gwt_client_util_ObjectPool_2_classLit;
}

function ObjectPool(){
}

_ = ObjectPool.prototype = new Object_0;
_.getClass$ = getClass_123;
_.typeId$ = 59;
_.factory = null;
var map_1;
function $get_2(this$static){
  this$static.pos == this$static.list.size && $add_7(this$static.list, this$static.factory.create());
  return $get_6(this$static.list, this$static.pos++);
}

function $pop(this$static){
  this$static.pos = this$static.stack_0[--this$static.stackCount];
}

function $push(this$static){
  this$static.stack_0[this$static.stackCount++] = this$static.pos;
}

function getClass_124(){
  return Lcom_bulletphysics_gwt_client_util_StackList_2_classLit;
}

function StackList(){
}

_ = StackList.prototype = new Object_0;
_.getClass$ = getClass_124;
_.typeId$ = 0;
_.pos = 0;
_.stackCount = 0;
function $ObjectStackList(this$static, factory){
  this$static.list = $ArrayList(new ArrayList);
  this$static.stack_0 = initDim(_3I_classLit, 150, -1, 512, 1);
  this$static.factory = factory;
  return this$static;
}

function getClass_125(){
  return Lcom_bulletphysics_gwt_client_util_ObjectStackList_2_classLit;
}

function ObjectStackList(){
}

_ = ObjectStackList.prototype = new StackList;
_.getClass$ = getClass_125;
_.typeId$ = 0;
_.factory = null;
function $Matrix3f(this$static, m1){
  this$static.m00 = m1.m00;
  this$static.m01 = m1.m01;
  this$static.m02 = m1.m02;
  this$static.m10 = m1.m10;
  this$static.m11 = m1.m11;
  this$static.m12 = m1.m12;
  this$static.m20 = m1.m20;
  this$static.m21 = m1.m21;
  this$static.m22 = m1.m22;
  return this$static;
}

function $Matrix3f_0(this$static){
  this$static.m00 = 0;
  this$static.m01 = 0;
  this$static.m02 = 0;
  this$static.m10 = 0;
  this$static.m11 = 0;
  this$static.m12 = 0;
  this$static.m20 = 0;
  this$static.m21 = 0;
  this$static.m22 = 0;
  return this$static;
}

function $equals_1(this$static, m1){
  var $e0;
  try {
    return this$static.m00 == m1.m00 && this$static.m01 == m1.m01 && this$static.m02 == m1.m02 && this$static.m10 == m1.m10 && this$static.m11 == m1.m11 && this$static.m12 == m1.m12 && this$static.m20 == m1.m20 && this$static.m21 == m1.m21 && this$static.m22 == m1.m22;
  }
   catch ($e0) {
    $e0 = caught_0($e0);
    if (instanceOf($e0, 64)) {
      return false;
    }
     else 
      throw $e0;
  }
}

function $getElement_0(this$static, row, column){
  switch (row) {
    case 0:
      switch (column) {
        case 0:
          return this$static.m00;
        case 1:
          return this$static.m01;
        case 2:
          return this$static.m02;
      }

      break;
    case 1:
      switch (column) {
        case 0:
          return this$static.m10;
        case 1:
          return this$static.m11;
        case 2:
          return this$static.m12;
      }

      break;
    case 2:
      switch (column) {
        case 0:
          return this$static.m20;
        case 1:
          return this$static.m21;
        case 2:
          return this$static.m22;
      }

  }
  throw $ArrayIndexOutOfBoundsException(new ArrayIndexOutOfBoundsException, 'n/a');
}

function $getRow(this$static, row, v){
  if (row == 0) {
    v.x = this$static.m00;
    v.y = this$static.m01;
    v.z = this$static.m02;
  }
   else if (row == 1) {
    v.x = this$static.m10;
    v.y = this$static.m11;
    v.z = this$static.m12;
  }
   else if (row == 2) {
    v.x = this$static.m20;
    v.y = this$static.m21;
    v.z = this$static.m22;
  }
   else {
    throw $ArrayIndexOutOfBoundsException(new ArrayIndexOutOfBoundsException, 'n/a');
  }
}

function $hashCode_1(this$static){
  var bits;
  bits = 1;
  bits = 31 * bits + floatToIntBits(this$static.m00);
  bits = 31 * bits + floatToIntBits(this$static.m01);
  bits = 31 * bits + floatToIntBits(this$static.m02);
  bits = 31 * bits + floatToIntBits(this$static.m10);
  bits = 31 * bits + floatToIntBits(this$static.m11);
  bits = 31 * bits + floatToIntBits(this$static.m12);
  bits = 31 * bits + floatToIntBits(this$static.m20);
  bits = 31 * bits + floatToIntBits(this$static.m21);
  bits = 31 * bits + floatToIntBits(this$static.m22);
  return bits ^ bits >> 32;
}

function $mul_1(this$static, m1){
  var m00, m01, m02, m10, m11, m12, m20, m21, m22;
  m00 = this$static.m00 * m1.m00 + this$static.m01 * m1.m10 + this$static.m02 * m1.m20;
  m01 = this$static.m00 * m1.m01 + this$static.m01 * m1.m11 + this$static.m02 * m1.m21;
  m02 = this$static.m00 * m1.m02 + this$static.m01 * m1.m12 + this$static.m02 * m1.m22;
  m10 = this$static.m10 * m1.m00 + this$static.m11 * m1.m10 + this$static.m12 * m1.m20;
  m11 = this$static.m10 * m1.m01 + this$static.m11 * m1.m11 + this$static.m12 * m1.m21;
  m12 = this$static.m10 * m1.m02 + this$static.m11 * m1.m12 + this$static.m12 * m1.m22;
  m20 = this$static.m20 * m1.m00 + this$static.m21 * m1.m10 + this$static.m22 * m1.m20;
  m21 = this$static.m20 * m1.m01 + this$static.m21 * m1.m11 + this$static.m22 * m1.m21;
  m22 = this$static.m20 * m1.m02 + this$static.m21 * m1.m12 + this$static.m22 * m1.m22;
  this$static.m00 = m00;
  this$static.m01 = m01;
  this$static.m02 = m02;
  this$static.m10 = m10;
  this$static.m11 = m11;
  this$static.m12 = m12;
  this$static.m20 = m20;
  this$static.m21 = m21;
  this$static.m22 = m22;
}

function $mul_2(this$static, m1, m2){
  var m00, m01, m02, m10, m11, m12, m20, m21, m22;
  if (this$static != m1 && this$static != m2) {
    this$static.m00 = m1.m00 * m2.m00 + m1.m01 * m2.m10 + m1.m02 * m2.m20;
    this$static.m01 = m1.m00 * m2.m01 + m1.m01 * m2.m11 + m1.m02 * m2.m21;
    this$static.m02 = m1.m00 * m2.m02 + m1.m01 * m2.m12 + m1.m02 * m2.m22;
    this$static.m10 = m1.m10 * m2.m00 + m1.m11 * m2.m10 + m1.m12 * m2.m20;
    this$static.m11 = m1.m10 * m2.m01 + m1.m11 * m2.m11 + m1.m12 * m2.m21;
    this$static.m12 = m1.m10 * m2.m02 + m1.m11 * m2.m12 + m1.m12 * m2.m22;
    this$static.m20 = m1.m20 * m2.m00 + m1.m21 * m2.m10 + m1.m22 * m2.m20;
    this$static.m21 = m1.m20 * m2.m01 + m1.m21 * m2.m11 + m1.m22 * m2.m21;
    this$static.m22 = m1.m20 * m2.m02 + m1.m21 * m2.m12 + m1.m22 * m2.m22;
  }
   else {
    m00 = m1.m00 * m2.m00 + m1.m01 * m2.m10 + m1.m02 * m2.m20;
    m01 = m1.m00 * m2.m01 + m1.m01 * m2.m11 + m1.m02 * m2.m21;
    m02 = m1.m00 * m2.m02 + m1.m01 * m2.m12 + m1.m02 * m2.m22;
    m10 = m1.m10 * m2.m00 + m1.m11 * m2.m10 + m1.m12 * m2.m20;
    m11 = m1.m10 * m2.m01 + m1.m11 * m2.m11 + m1.m12 * m2.m21;
    m12 = m1.m10 * m2.m02 + m1.m11 * m2.m12 + m1.m12 * m2.m22;
    m20 = m1.m20 * m2.m00 + m1.m21 * m2.m10 + m1.m22 * m2.m20;
    m21 = m1.m20 * m2.m01 + m1.m21 * m2.m11 + m1.m22 * m2.m21;
    m22 = m1.m20 * m2.m02 + m1.m21 * m2.m12 + m1.m22 * m2.m22;
    this$static.m00 = m00;
    this$static.m01 = m01;
    this$static.m02 = m02;
    this$static.m10 = m10;
    this$static.m11 = m11;
    this$static.m12 = m12;
    this$static.m20 = m20;
    this$static.m21 = m21;
    this$static.m22 = m22;
  }
}

function $set_6(this$static, m1){
  this$static.m00 = m1.m00;
  this$static.m01 = m1.m01;
  this$static.m02 = m1.m02;
  this$static.m10 = m1.m10;
  this$static.m11 = m1.m11;
  this$static.m12 = m1.m12;
  this$static.m20 = m1.m20;
  this$static.m21 = m1.m21;
  this$static.m22 = m1.m22;
}

function $setIdentity_0(this$static){
  this$static.m00 = 1;
  this$static.m01 = 0;
  this$static.m02 = 0;
  this$static.m10 = 0;
  this$static.m11 = 1;
  this$static.m12 = 0;
  this$static.m20 = 0;
  this$static.m21 = 0;
  this$static.m22 = 1;
}

function $transform_0(this$static, t){
  var x, y, z;
  x = this$static.m00 * t.x + this$static.m01 * t.y + this$static.m02 * t.z;
  y = this$static.m10 * t.x + this$static.m11 * t.y + this$static.m12 * t.z;
  z = this$static.m20 * t.x + this$static.m21 * t.y + this$static.m22 * t.z;
  t.x = x;
  t.y = y;
  t.z = z;
}

function $transpose(this$static){
  var temp;
  temp = this$static.m10;
  this$static.m10 = this$static.m01;
  this$static.m01 = temp;
  temp = this$static.m20;
  this$static.m20 = this$static.m02;
  this$static.m02 = temp;
  temp = this$static.m21;
  this$static.m21 = this$static.m12;
  this$static.m12 = temp;
}

function equals_3(o1){
  var $e0, m2;
  try {
    m2 = dynamicCast(o1, 52);
    return this.m00 == m2.m00 && this.m01 == m2.m01 && this.m02 == m2.m02 && this.m10 == m2.m10 && this.m11 == m2.m11 && this.m12 == m2.m12 && this.m20 == m2.m20 && this.m21 == m2.m21 && this.m22 == m2.m22;
  }
   catch ($e0) {
    $e0 = caught_0($e0);
    if (instanceOf($e0, 65)) {
      return false;
    }
     else if (instanceOf($e0, 64)) {
      return false;
    }
     else 
      throw $e0;
  }
}

function getClass_126(){
  return Lcom_bulletphysics_gwt_client_vecmath_Matrix3f_2_classLit;
}

function hashCode_4(){
  return $hashCode_1(this);
}

function toString_3(){
  return this.m00 + ', ' + this.m01 + ', ' + this.m02 + '\n' + this.m10 + ', ' + this.m11 + ', ' + this.m12 + '\n' + this.m20 + ', ' + this.m21 + ', ' + this.m22 + '\n';
}

function Matrix3f(){
}

_ = Matrix3f.prototype = new Object_0;
_.equals$ = equals_3;
_.getClass$ = getClass_126;
_.hashCode$ = hashCode_4;
_.toString$ = toString_3;
_.typeId$ = 60;
_.m00 = 0;
_.m01 = 0;
_.m02 = 0;
_.m10 = 0;
_.m11 = 0;
_.m12 = 0;
_.m20 = 0;
_.m21 = 0;
_.m22 = 0;
function $Tuple4f_0(this$static){
  this$static.x = 0;
  this$static.y = 0;
  this$static.z = 0;
  this$static.w = 0;
  return this$static;
}

function $set_7(this$static, x, y, z, w){
  this$static.x = x;
  this$static.y = y;
  this$static.z = z;
  this$static.w = w;
}

function equals_4(t1){
  var $e0, t2;
  try {
    t2 = dynamicCast(t1, 66);
    return this.x == t2.x && this.y == t2.y && this.z == t2.z && this.w == t2.w;
  }
   catch ($e0) {
    $e0 = caught_0($e0);
    if (instanceOf($e0, 64)) {
      return false;
    }
     else if (instanceOf($e0, 65)) {
      return false;
    }
     else 
      throw $e0;
  }
}

function getClass_127(){
  return Lcom_bulletphysics_gwt_client_vecmath_Tuple4f_2_classLit;
}

function hashCode_5(){
  var bits;
  bits = 1;
  bits = 31 * bits + floatToIntBits(this.x);
  bits = 31 * bits + floatToIntBits(this.y);
  bits = 31 * bits + floatToIntBits(this.z);
  bits = 31 * bits + floatToIntBits(this.w);
  return bits ^ bits >> 32;
}

function toString_4(){
  return '(' + this.x + ', ' + this.y + ', ' + this.z + ', ' + this.w + ')';
}

function Tuple4f(){
}

_ = Tuple4f.prototype = new Object_0;
_.equals$ = equals_4;
_.getClass$ = getClass_127;
_.hashCode$ = hashCode_5;
_.toString$ = toString_4;
_.typeId$ = 61;
_.w = 0;
_.x = 0;
_.y = 0;
_.z = 0;
function $Quat4f(this$static){
  $Tuple4f_0(this$static);
  return this$static;
}

function $mul_3(this$static, q1, q2){
  var w, x, y;
  if (this$static != q1 && this$static != q2) {
    this$static.w = q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z;
    this$static.x = q1.w * q2.x + q2.w * q1.x + q1.y * q2.z - q1.z * q2.y;
    this$static.y = q1.w * q2.y + q2.w * q1.y - q1.x * q2.z + q1.z * q2.x;
    this$static.z = q1.w * q2.z + q2.w * q1.z + q1.x * q2.y - q1.y * q2.x;
  }
   else {
    w = q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z;
    x = q1.w * q2.x + q2.w * q1.x + q1.y * q2.z - q1.z * q2.y;
    y = q1.w * q2.y + q2.w * q1.y - q1.x * q2.z + q1.z * q2.x;
    this$static.z = q1.w * q2.z + q2.w * q1.z + q1.x * q2.y - q1.y * q2.x;
    this$static.w = w;
    this$static.x = x;
    this$static.y = y;
  }
}

function $normalize(this$static){
  var norm;
  norm = this$static.x * this$static.x + this$static.y * this$static.y + this$static.z * this$static.z + this$static.w * this$static.w;
  if (norm > 0) {
    norm = 1 / Math.sqrt(norm);
    this$static.x *= norm;
    this$static.y *= norm;
    this$static.z *= norm;
    this$static.w *= norm;
  }
   else {
    this$static.x = 0;
    this$static.y = 0;
    this$static.z = 0;
    this$static.w = 0;
  }
}

function getClass_128(){
  return Lcom_bulletphysics_gwt_client_vecmath_Quat4f_2_classLit;
}

function Quat4f(){
}

_ = Quat4f.prototype = new Tuple4f;
_.getClass$ = getClass_128;
_.typeId$ = 62;
function floatToIntBits(f){
  if (f == 0) {
    return 0;
  }
   else {
    return ~~Math.max(Math.min(f * 1000, 2147483647), -2147483648);
  }
}

function $Vector3f(this$static, x, y, z){
  this$static.x = x;
  this$static.y = y;
  this$static.z = z;
  return this$static;
}

function $Vector3f_0(this$static, t){
  this$static.x = t[0];
  this$static.y = t[1];
  this$static.z = t[2];
  return this$static;
}

function $Vector3f_1(this$static, t1){
  this$static.x = t1.x;
  this$static.y = t1.y;
  this$static.z = t1.z;
  return this$static;
}

function $Vector3f_2(this$static){
  this$static.x = 0;
  this$static.y = 0;
  this$static.z = 0;
  return this$static;
}

function $add_1(this$static, t1, t2){
  this$static.x = t1.x + t2.x;
  this$static.y = t1.y + t2.y;
  this$static.z = t1.z + t2.z;
}

function $add_2(this$static, t1){
  this$static.x += t1.x;
  this$static.y += t1.y;
  this$static.z += t1.z;
}

function $cross(this$static, v1, v2){
  var x, y;
  x = v1.y * v2.z - v1.z * v2.y;
  y = v2.x * v1.z - v2.z * v1.x;
  this$static.z = v1.x * v2.y - v1.y * v2.x;
  this$static.x = x;
  this$static.y = y;
}

function $dot(this$static, v1){
  return this$static.x * v1.x + this$static.y * v1.y + this$static.z * v1.z;
}

function $equals_2(this$static, t1){
  var $e0;
  try {
    return this$static.x == t1.x && this$static.y == t1.y && this$static.z == t1.z;
  }
   catch ($e0) {
    $e0 = caught_0($e0);
    if (instanceOf($e0, 64)) {
      return false;
    }
     else 
      throw $e0;
  }
}

function $hashCode_2(this$static){
  var bits;
  bits = 1;
  bits = 31 * bits + floatToIntBits(this$static.x);
  bits = 31 * bits + floatToIntBits(this$static.y);
  bits = 31 * bits + floatToIntBits(this$static.z);
  return bits ^ bits >> 32;
}

function $length(this$static){
  return Math.sqrt(this$static.x * this$static.x + this$static.y * this$static.y + this$static.z * this$static.z);
}

function $lengthSquared(this$static){
  return this$static.x * this$static.x + this$static.y * this$static.y + this$static.z * this$static.z;
}

function $negate(this$static, t1){
  this$static.x = -t1.x;
  this$static.y = -t1.y;
  this$static.z = -t1.z;
}

function $normalize_0(this$static, v1){
  var norm;
  norm = 1 / Math.sqrt(v1.x * v1.x + v1.y * v1.y + v1.z * v1.z);
  this$static.x = v1.x * norm;
  this$static.y = v1.y * norm;
  this$static.z = v1.z * norm;
}

function $normalize_1(this$static){
  var norm;
  norm = 1 / Math.sqrt(this$static.x * this$static.x + this$static.y * this$static.y + this$static.z * this$static.z);
  this$static.x *= norm;
  this$static.y *= norm;
  this$static.z *= norm;
}

function $scale(this$static, s, t1){
  this$static.x = s * t1.x;
  this$static.y = s * t1.y;
  this$static.z = s * t1.z;
}

function $scale_0(this$static, s){
  this$static.x *= s;
  this$static.y *= s;
  this$static.z *= s;
}

function $scaleAdd(this$static, s, t1, t2){
  this$static.x = s * t1.x + t2.x;
  this$static.y = s * t1.y + t2.y;
  this$static.z = s * t1.z + t2.z;
}

function $set_8(this$static, x, y, z){
  this$static.x = x;
  this$static.y = y;
  this$static.z = z;
}

function $set_9(this$static, t1){
  this$static.x = t1.x;
  this$static.y = t1.y;
  this$static.z = t1.z;
}

function $sub(this$static, t1, t2){
  this$static.x = t1.x - t2.x;
  this$static.y = t1.y - t2.y;
  this$static.z = t1.z - t2.z;
}

function $sub_0(this$static, t1){
  this$static.x -= t1.x;
  this$static.y -= t1.y;
  this$static.z -= t1.z;
}

function equals_5(t1){
  var $e0, t2;
  try {
    t2 = dynamicCast(t1, 53);
    return this.x == t2.x && this.y == t2.y && this.z == t2.z;
  }
   catch ($e0) {
    $e0 = caught_0($e0);
    if (instanceOf($e0, 64)) {
      return false;
    }
     else if (instanceOf($e0, 65)) {
      return false;
    }
     else 
      throw $e0;
  }
}

function getClass_129(){
  return Lcom_bulletphysics_gwt_client_vecmath_Vector3f_2_classLit;
}

function hashCode_6(){
  return $hashCode_2(this);
}

function toString_5(){
  return '(' + this.x + ', ' + this.y + ', ' + this.z + ')';
}

function Vector3f(){
}

_ = Vector3f.prototype = new Object_0;
_.equals$ = equals_5;
_.getClass$ = getClass_129;
_.hashCode$ = hashCode_6;
_.toString$ = toString_5;
_.typeId$ = 63;
_.x = 0;
_.y = 0;
_.z = 0;
function $Vector4f(this$static, v1){
  this$static.x = v1.x;
  this$static.y = v1.y;
  this$static.z = v1.z;
  this$static.w = v1.w;
  return this$static;
}

function $Vector4f_0(this$static){
  $Tuple4f_0(this$static);
  return this$static;
}

function getClass_130(){
  return Lcom_bulletphysics_gwt_client_vecmath_Vector4f_2_classLit;
}

function Vector4f(){
}

_ = Vector4f.prototype = new Tuple4f;
_.getClass$ = getClass_130;
_.typeId$ = 64;
function $setStackTrace(stackTrace){
  var c, copy, i;
  copy = initDim(_3Ljava_lang_StackTraceElement_2_classLit, 158, 59, stackTrace.length, 0);
  for (i = 0 , c = stackTrace.length; i < c; ++i) {
    if (!stackTrace[i]) {
      throw $NullPointerException(new NullPointerException);
    }
    copy[i] = stackTrace[i];
  }
}

function getClass_131(){
  return Ljava_lang_Throwable_2_classLit;
}

function getMessage(){
  return this.detailMessage;
}

function toString_6(){
  var className, msg;
  className = this.getClass$().typeName;
  msg = this.getMessage();
  if (msg != null) {
    return className + ': ' + msg;
  }
   else {
    return className;
  }
}

function Throwable(){
}

_ = Throwable.prototype = new Object_0;
_.getClass$ = getClass_131;
_.getMessage = getMessage;
_.toString$ = toString_6;
_.typeId$ = 65;
_.detailMessage = null;
function $Exception(this$static, message){
  $fillInStackTrace();
  this$static.detailMessage = message;
  return this$static;
}

function getClass_132(){
  return Ljava_lang_Exception_2_classLit;
}

function Exception(){
}

_ = Exception.prototype = new Throwable;
_.getClass$ = getClass_132;
_.typeId$ = 66;
function $RuntimeException(this$static){
  $fillInStackTrace();
  return this$static;
}

function $RuntimeException_0(this$static, message){
  $fillInStackTrace();
  this$static.detailMessage = message;
  return this$static;
}

function getClass_133(){
  return Ljava_lang_RuntimeException_2_classLit;
}

function RuntimeException(){
}

_ = RuntimeException.prototype = new Exception;
_.getClass$ = getClass_133;
_.typeId$ = 67;
function $JavaScriptException(this$static, e){
  $fillInStackTrace();
  this$static.e = e;
  $createStackTrace(this$static);
  return this$static;
}

function getClass_134(){
  return Lcom_google_gwt_core_client_JavaScriptException_2_classLit;
}

function getDescription(e){
  if (e != null && e.typeMarker$ != nullMethod && e.typeId$ != 2) {
    return getDescription0(dynamicCastJso(e));
  }
   else {
    return e + '';
  }
}

function getDescription0(e){
  return e == null?null:e.message;
}

function getMessage_0(){
  this.message_0 == null && (this.name_0 = getName(this.e) , this.description = getDescription(this.e) , this.message_0 = '(' + this.name_0 + '): ' + this.description + getProperties(this.e) , undefined);
  return this.message_0;
}

function getName(e){
  if (e == null) {
    return 'null';
  }
   else if (e != null && e.typeMarker$ != nullMethod && e.typeId$ != 2) {
    return getName0(dynamicCastJso(e));
  }
   else if (e != null && canCast(e.typeId$, 1)) {
    return 'String';
  }
   else {
    return (e.typeMarker$ == nullMethod || e.typeId$ == 2?e.getClass$():Lcom_google_gwt_core_client_JavaScriptObject_2_classLit).typeName;
  }
}

function getName0(e){
  return e == null?null:e.name;
}

function getProperties(e){
  return e != null && e.typeMarker$ != nullMethod && e.typeId$ != 2?getProperties0(dynamicCastJso(e)):'';
}

function getProperties0(e){
  var result = '';
  try {
    for (prop in e) {
      if (prop != 'name' && prop != 'message' && prop != 'toString') {
        try {
          result += '\n ' + prop + ': ' + e[prop];
        }
         catch (ignored) {
        }
      }
    }
  }
   catch (ignored) {
  }
  return result;
}

function JavaScriptException(){
}

_ = JavaScriptException.prototype = new RuntimeException;
_.getClass$ = getClass_134;
_.getMessage = getMessage_0;
_.typeId$ = 68;
_.description = null;
_.e = null;
_.message_0 = null;
_.name_0 = null;
function equals__devirtual$(this$static, other){
  return this$static.typeMarker$ == nullMethod || this$static.typeId$ == 2?this$static.equals$(other):(this$static == null?null:this$static) === (other == null?null:other);
}

function hashCode__devirtual$(this$static){
  return this$static.typeMarker$ == nullMethod || this$static.typeId$ == 2?this$static.hashCode$():this$static.$H || (this$static.$H = ++sNextHashId);
}

function toString__devirtual$(this$static){
  return this$static.typeMarker$ == nullMethod || this$static.typeId$ == 2?this$static.toString$():this$static.toString?this$static.toString():'[JavaScriptObject]';
}

function getClass_136(){
  return Lcom_google_gwt_core_client_Scheduler_2_classLit;
}

function Scheduler(){
}

_ = Scheduler.prototype = new Object_0;
_.getClass$ = getClass_136;
_.typeId$ = 0;
function entry_0(jsFunction){
  return function(){
    return entry0(jsFunction, this, arguments);
  }
  ;
}

function entry0(jsFunction, thisObj, arguments_0){
  var initialEntry;
  initialEntry = entryDepth++ == 0;
  try {
    return jsFunction.apply(thisObj, arguments_0);
  }
   finally {
    initialEntry && $flushFinallyCommands(($clinit_169() , INSTANCE_0));
    --entryDepth;
  }
}

var entryDepth = 0, sNextHashId = 0;
function $clinit_169(){
  $clinit_169 = nullMethod;
  INSTANCE_0 = $SchedulerImpl(new SchedulerImpl);
}

function $SchedulerImpl(this$static){
  $clinit_169();
  this$static.flusher = $SchedulerImpl$1(new SchedulerImpl$1, this$static);
  $SchedulerImpl$2(new SchedulerImpl$2, this$static);
  this$static.deferredCommands = [];
  this$static.incrementalCommands = [];
  this$static.finallyCommands = [];
  return this$static;
}

function $flushFinallyCommands(this$static){
  var oldFinally;
  oldFinally = this$static.finallyCommands;
  this$static.finallyCommands = [];
  runScheduledTasks(oldFinally, this$static.finallyCommands);
}

function $flushPostEventPumpCommands(this$static){
  var oldDeferred;
  oldDeferred = this$static.deferredCommands;
  this$static.deferredCommands = [];
  runScheduledTasks(oldDeferred, this$static.incrementalCommands);
  this$static.incrementalCommands = runRepeatingTasks(this$static.incrementalCommands);
}

function $isWorkQueued(this$static){
  return this$static.deferredCommands.length > 0 || this$static.incrementalCommands.length > 0;
}

function execute(cmd){
  return cmd.execute();
}

function getClass_137(){
  return Lcom_google_gwt_core_client_impl_SchedulerImpl_2_classLit;
}

function runRepeatingTasks(tasks){
  var canceledSomeTasks, i, length_0, newTasks, start, t;
  canceledSomeTasks = false;
  length_0 = tasks.length;
  start = (new Date).getTime();
  while ((new Date).getTime() - start < 100) {
    for (i = 0; i < length_0; ++i) {
      t = tasks[i];
      if (!t) {
        continue;
      }
      if (!t[0].execute()) {
        tasks[i] = null;
        canceledSomeTasks = true;
      }
    }
  }
  if (canceledSomeTasks) {
    newTasks = [];
    for (i = 0; i < length_0; ++i) {
      if (!tasks[i]) {
        continue;
      }
      newTasks[newTasks.length] = tasks[i];
    }
    return newTasks;
  }
   else {
    return tasks;
  }
}

function runScheduledTasks(tasks, rescheduled){
  var $e0, i, j, t;
  for (i = 0 , j = tasks.length; i < j; ++i) {
    t = tasks[i];
    try {
      t[1]?t[0].execute() && (rescheduled[rescheduled.length] = t , undefined):t[0].nullMethod();
    }
     catch ($e0) {
      $e0 = caught_0($e0);
      if (!instanceOf($e0, 67))
        throw $e0;
    }
  }
}

function scheduleFixedDelayImpl(cmd, delayMs){
  $clinit_169();
  $wnd.setTimeout(function(){
    var ret = $entry(execute)(cmd);
    ret && $wnd.setTimeout(arguments.callee, delayMs);
  }
  , delayMs);
}

function SchedulerImpl(){
}

_ = SchedulerImpl.prototype = new Scheduler;
_.getClass$ = getClass_137;
_.typeId$ = 0;
_.flushRunning = false;
_.shouldBeRunning = false;
var INSTANCE_0;
function $SchedulerImpl$1(this$static, this$0){
  this$static.this$0 = this$0;
  return this$static;
}

function execute_0(){
  this.this$0.flushRunning = true;
  $flushPostEventPumpCommands(this.this$0);
  this.this$0.flushRunning = false;
  return this.this$0.shouldBeRunning = $isWorkQueued(this.this$0);
}

function getClass_138(){
  return Lcom_google_gwt_core_client_impl_SchedulerImpl$1_2_classLit;
}

function SchedulerImpl$1(){
}

_ = SchedulerImpl$1.prototype = new Object_0;
_.execute = execute_0;
_.getClass$ = getClass_138;
_.typeId$ = 0;
_.this$0 = null;
function $SchedulerImpl$2(this$static, this$0){
  this$static.this$0 = this$0;
  return this$static;
}

function execute_1(){
  this.this$0.flushRunning && scheduleFixedDelayImpl(this.this$0.flusher, 1);
  return this.this$0.shouldBeRunning;
}

function getClass_139(){
  return Lcom_google_gwt_core_client_impl_SchedulerImpl$2_2_classLit;
}

function SchedulerImpl$2(){
}

_ = SchedulerImpl$2.prototype = new Object_0;
_.execute = execute_1;
_.getClass$ = getClass_139;
_.typeId$ = 0;
_.this$0 = null;
function extractNameFromToString(fnToString){
  var index, start, toReturn;
  toReturn = '';
  fnToString = $trim(fnToString);
  index = fnToString.indexOf('(');
  if (index != -1) {
    start = fnToString.indexOf('function') == 0?8:0;
    toReturn = $trim(fnToString.substr(start, index - start));
  }
  return toReturn.length > 0?toReturn:'anonymous';
}

function splice(arr, length_0){
  arr.length >= length_0 && arr.splice(0, length_0);
  return arr;
}

function $createStackTrace(e){
  var i, j, stack, stackTrace;
  stack = $inferFrom(instanceOfJso(e.e)?dynamicCastJso(e.e):null);
  stackTrace = initDim(_3Ljava_lang_StackTraceElement_2_classLit, 158, 59, stack.length, 0);
  for (i = 0 , j = stackTrace.length; i < j; ++i) {
    stackTrace[i] = $StackTraceElement(new StackTraceElement, 'Unknown', stack[i], 'Unknown source', 0);
  }
  $setStackTrace(stackTrace);
}

--></script>
<script><!--
function $fillInStackTrace(){
  var i, j, stack, stackTrace;
  stack = splice($inferFrom($makeException()), 2);
  stackTrace = initDim(_3Ljava_lang_StackTraceElement_2_classLit, 158, 59, stack.length, 0);
  for (i = 0 , j = stackTrace.length; i < j; ++i) {
    stackTrace[i] = $StackTraceElement(new StackTraceElement, 'Unknown', stack[i], 'Unknown source', 0);
  }
  $setStackTrace(stackTrace);
}

function $makeException(){
  try {
    null.a();
  }
   catch (e) {
    return e;
  }
}

function $inferFrom(e){
  var i, j, stack;
  stack = e && e.stack?e.stack.split('\n'):[];
  for (i = 0 , j = stack.length; i < j; ++i) {
    stack[i] = extractNameFromToString(stack[i]);
  }
  return stack;
}

function getClass_140(){
  return Lcom_google_gwt_core_client_impl_StringBufferImpl_2_classLit;
}

function StringBufferImpl(){
}

_ = StringBufferImpl.prototype = new Object_0;
_.getClass$ = getClass_140;
_.typeId$ = 0;
function getClass_141(){
  return Lcom_google_gwt_core_client_impl_StringBufferImplAppend_2_classLit;
}

function StringBufferImplAppend(){
}

_ = StringBufferImplAppend.prototype = new StringBufferImpl;
_.getClass$ = getClass_141;
_.typeId$ = 0;
_.string = '';
function $clinit_178(){
  $clinit_178 = nullMethod;
  $clinit_180();
  new DOMImplMozilla;
}

function getClass_142(){
  return Lcom_google_gwt_dom_client_DOMImpl_2_classLit;
}

function DOMImpl(){
}

_ = DOMImpl.prototype = new Object_0;
_.getClass$ = getClass_142;
_.typeId$ = 0;
function $clinit_179(){
  $clinit_179 = nullMethod;
  $clinit_178();
}

function getClass_143(){
  return Lcom_google_gwt_dom_client_DOMImplStandard_2_classLit;
}

function DOMImplStandard(){
}

_ = DOMImplStandard.prototype = new DOMImpl;
_.getClass$ = getClass_143;
_.typeId$ = 0;
function $clinit_180(){
  $clinit_180 = nullMethod;
  $clinit_179();
}

function $eventGetRelatedTarget(evt){
  var relatedTarget = evt.relatedTarget;
  try {
    var nodeName = relatedTarget.nodeName;
    return relatedTarget;
  }
   catch (e) {
    return null;
  }
}

function $isOrHasChild(parent_0, child){
  return parent_0 === child || !!(parent_0.compareDocumentPosition(child) & 16);
}

function $toString_1(elem){
  var doc = elem.ownerDocument;
  var temp = elem.cloneNode(true);
  var tempDiv = doc.createElement('DIV');
  tempDiv.appendChild(temp);
  outer = tempDiv.innerHTML;
  temp.innerHTML = '';
  return outer;
}

function getClass_144(){
  return Lcom_google_gwt_dom_client_DOMImplMozilla_2_classLit;
}

function DOMImplMozilla(){
}

_ = DOMImplMozilla.prototype = new DOMImplStandard;
_.getClass$ = getClass_144;
_.typeId$ = 0;
function getClass_145(){
  return Lcom_google_gwt_event_shared_GwtEvent_2_classLit;
}

function toString_8(){
  return 'An event type';
}

function GwtEvent(){
}

_ = GwtEvent.prototype = new Object_0;
_.getClass$ = getClass_145;
_.toString$ = toString_8;
_.typeId$ = 0;
_.dead = false;
_.source = null;
function dispatch(p0){
  dynamicCast(p0, 68).onClose(this);
}

function fire(source){
  var event_0;
  if (TYPE) {
    event_0 = new CloseEvent;
    $fireEvent(source, event_0);
  }
}

function getAssociatedType(){
  return TYPE;
}

function getClass_146(){
  return Lcom_google_gwt_event_logical_shared_CloseEvent_2_classLit;
}

function CloseEvent(){
}

_ = CloseEvent.prototype = new GwtEvent;
_.dispatch = dispatch;
_.getAssociatedType = getAssociatedType;
_.getClass$ = getClass_146;
_.typeId$ = 0;
var TYPE = null;
function getClass_147(){
  return Lcom_google_gwt_event_shared_DefaultHandlerRegistration_2_classLit;
}

function DefaultHandlerRegistration(){
}

_ = DefaultHandlerRegistration.prototype = new Object_0;
_.getClass$ = getClass_147;
_.typeId$ = 0;
function $GwtEvent$Type(this$static){
  this$static.index = ++nextHashCode;
  return this$static;
}

function getClass_148(){
  return Lcom_google_gwt_event_shared_GwtEvent$Type_2_classLit;
}

function hashCode_8(){
  return this.index;
}

function toString_9(){
  return 'Event type';
}

function GwtEvent$Type(){
}

_ = GwtEvent$Type.prototype = new Object_0;
_.getClass$ = getClass_148;
_.hashCode$ = hashCode_8;
_.toString$ = toString_9;
_.typeId$ = 0;
_.index = 0;
var nextHashCode = 0;
function $addHandler(this$static, type, handler){
  this$static.firingDepth > 0?$defer(this$static, $HandlerManager$1(new HandlerManager$1, this$static, type, handler)):$addHandler_0(this$static.registry, type, handler);
  return new DefaultHandlerRegistration;
}

function $defer(this$static, command){
  !this$static.deferredDeltas && (this$static.deferredDeltas = $ArrayList(new ArrayList));
  $add_7(this$static.deferredDeltas, command);
}

function $fireEvent(this$static, event_0){
  var oldSource;
  if (event_0.dead) {
    event_0.dead = false;
    event_0.source = null;
  }
  oldSource = event_0.source;
  event_0.source = this$static.source;
  try {
    ++this$static.firingDepth;
    $fireEvent_0(this$static.registry, event_0, this$static.isReverseOrder);
  }
   finally {
    --this$static.firingDepth;
    this$static.firingDepth == 0 && $handleQueuedAddsAndRemoves(this$static);
  }
  if (oldSource == null) {
    event_0.dead = true;
    event_0.source = null;
  }
   else {
    event_0.source = oldSource;
  }
}

function $handleQueuedAddsAndRemoves(this$static){
  var c, c$iterator;
  if (this$static.deferredDeltas) {
    try {
      for (c$iterator = $AbstractList$IteratorImpl(new AbstractList$IteratorImpl, this$static.deferredDeltas); c$iterator.i < c$iterator.this$0.size_0();) {
        c = dynamicCast($next_3(c$iterator), 69);
        $addHandler_0(c.this$0.registry, c.val$type, c.val$handler);
      }
    }
     finally {
      this$static.deferredDeltas = null;
    }
  }
}

function getClass_149(){
  return Lcom_google_gwt_event_shared_HandlerManager_2_classLit;
}

function HandlerManager(){
}

_ = HandlerManager.prototype = new Object_0;
_.getClass$ = getClass_149;
_.typeId$ = 0;
_.deferredDeltas = null;
_.firingDepth = 0;
_.isReverseOrder = false;
_.registry = null;
_.source = null;
function $HandlerManager$1(this$static, this$0, val$type, val$handler){
  this$static.this$0 = this$0;
  this$static.val$type = val$type;
  this$static.val$handler = val$handler;
  return this$static;
}

function getClass_150(){
  return Lcom_google_gwt_event_shared_HandlerManager$1_2_classLit;
}

function HandlerManager$1(){
}

_ = HandlerManager$1.prototype = new Object_0;
_.getClass$ = getClass_150;
_.typeId$ = 69;
_.this$0 = null;
_.val$handler = null;
_.val$type = null;
function $HandlerManager$HandlerRegistry(this$static){
  this$static.map = $HashMap(new HashMap);
  return this$static;
}

function $addHandler_0(this$static, type, handler){
  var l;
  l = dynamicCast($get_5(this$static.map, type), 70);
  if (!l) {
    l = $ArrayList(new ArrayList);
    $put(this$static.map, type, l);
  }
  setCheck(l.array, l.size++, handler);
}

function $fireEvent_0(this$static, event_0, isReverseOrder){
  var count, handler, i, type, l, l_0, l_1;
  type = event_0.getAssociatedType();
  count = (l = dynamicCast($get_5(this$static.map, type), 70) , !l?0:l.size);
  if (isReverseOrder) {
    for (i = count - 1; i >= 0; --i) {
      handler = (l_0 = dynamicCast($get_5(this$static.map, type), 70) , dynamicCast((checkIndex(i, l_0.size) , l_0.array[i]), 71));
      event_0.dispatch(handler);
    }
  }
   else {
    for (i = 0; i < count; ++i) {
      handler = (l_1 = dynamicCast($get_5(this$static.map, type), 70) , dynamicCast((checkIndex(i, l_1.size) , l_1.array[i]), 71));
      event_0.dispatch(handler);
    }
  }
}

function getClass_151(){
  return Lcom_google_gwt_event_shared_HandlerManager$HandlerRegistry_2_classLit;
}

function HandlerManager$HandlerRegistry(){
}

_ = HandlerManager$HandlerRegistry.prototype = new Object_0;
_.getClass$ = getClass_151;
_.typeId$ = 0;
function createFrom(array, length_0){
  var a, result;
  a = array;
  result = createFromSeed(0, length_0);
  initValues(a.arrayClass$, a.typeId$, a.queryId$, result);
  return result;
}

function createFromSeed(seedType, length_0){
  var array = new Array(length_0);
  if (seedType > 0) {
    var value = [null, 0, false, [0, 0]][seedType];
    for (var i = 0; i < length_0; ++i) {
      array[i] = value;
    }
  }
  return array;
}

function getClass_152(){
  return this.arrayClass$;
}

function initDim(arrayClass, typeId, queryId, length_0, seedType){
  var result;
  result = createFromSeed(seedType, length_0);
  $clinit_209();
  wrapArray(result, expandoNames_0, expandoValues_0);
  result.arrayClass$ = arrayClass;
  result.typeId$ = typeId;
  result.queryId$ = queryId;
  return result;
}

function initDims_0(arrayClasses, typeIdExprs, queryIdExprs, dimExprs, index, count, seedType){
  var i, isLastDim, length_0, result;
  length_0 = dimExprs[index];
  isLastDim = index == count - 1;
  result = createFromSeed(isLastDim?seedType:0, length_0);
  $clinit_209();
  wrapArray(result, expandoNames_0, expandoValues_0);
  result.arrayClass$ = arrayClasses[index];
  result.typeId$ = typeIdExprs[index];
  result.queryId$ = queryIdExprs[index];
  if (!isLastDim) {
    ++index;
    for (i = 0; i < length_0; ++i) {
      result[i] = initDims_0(arrayClasses, typeIdExprs, queryIdExprs, dimExprs, index, count, seedType);
    }
  }
  return result;
}

function initValues(arrayClass, typeId, queryId, array){
  $clinit_209();
  wrapArray(array, expandoNames_0, expandoValues_0);
  array.arrayClass$ = arrayClass;
  array.typeId$ = typeId;
  array.queryId$ = queryId;
  return array;
}

function setCheck(array, index, value){
  if (value != null) {
    if (array.queryId$ > 0 && !canCastUnsafe(value.typeId$, array.queryId$)) {
      throw $ArrayStoreException(new ArrayStoreException);
    }
    if (array.queryId$ < 0 && (value.typeMarker$ == nullMethod || value.typeId$ == 2)) {
      throw $ArrayStoreException(new ArrayStoreException);
    }
  }
  return array[index] = value;
}

function Array_0(){
}

_ = Array_0.prototype = new Object_0;
_.getClass$ = getClass_152;
_.typeId$ = 0;
_.arrayClass$ = null;
_.length = 0;
_.queryId$ = 0;
function $clinit_209(){
  $clinit_209 = nullMethod;
  expandoNames_0 = [];
  expandoValues_0 = [];
  initExpandos(new Array_0, expandoNames_0, expandoValues_0);
}

function initExpandos(protoType, expandoNames, expandoValues){
  var i = 0, value;
  for (var name_0 in protoType) {
    if (value = protoType[name_0]) {
      expandoNames[i] = name_0;
      expandoValues[i] = value;
      ++i;
    }
  }
}

function wrapArray(array, expandoNames, expandoValues){
  $clinit_209();
  for (var i = 0, c = expandoNames.length; i < c; ++i) {
    array[expandoNames[i]] = expandoValues[i];
  }
}

var expandoNames_0, expandoValues_0;
function canCast(srcId, dstId){
  return srcId && !!typeIdArray[srcId][dstId];
}

function canCastUnsafe(srcId, dstId){
  return srcId && typeIdArray[srcId][dstId];
}

function dynamicCast(src, dstId){
  if (src != null && !canCastUnsafe(src.typeId$, dstId)) {
    throw $ClassCastException(new ClassCastException);
  }
  return src;
}

function dynamicCastJso(src){
  if (src != null && (src.typeMarker$ == nullMethod || src.typeId$ == 2)) {
    throw $ClassCastException(new ClassCastException);
  }
  return src;
}

function instanceOf(src, dstId){
  return src != null && canCast(src.typeId$, dstId);
}

function instanceOfJso(src){
  return src != null && src.typeMarker$ != nullMethod && src.typeId$ != 2;
}

function maskUndefined(src){
  return src == null?null:src;
}

function round_int(x){
  return ~~Math.max(Math.min(x, 2147483647), -2147483648);
}

function throwClassCastExceptionUnlessNull(o){
  if (o != null) {
    throw $ClassCastException(new ClassCastException);
  }
  return o;
}

var typeIdArray = [{}, {}, {1:1, 39:1, 41:1}, {13:1}, {13:1}, {3:1}, {2:1, 3:1}, {2:1, 3:1, 12:1}, {39:1, 41:1, 56:1}, {39:1, 41:1, 45:1, 56:1}, {14:1}, {18:1}, {39:1, 41:1, 46:1, 56:1}, {15:1}, {17:1}, {39:1, 41:1, 47:1, 56:1}, {18:1, 19:1}, {15:1}, {15:1}, {18:1, 20:1}, {15:1}, {15:1}, {18:1, 23:1}, {15:1}, {18:1, 24:1}, {15:1}, {18:1}, {15:1}, {18:1, 27:1}, {15:1}, {28:1}, {22:1}, {30:1}, {33:1}, {31:1}, {39:1, 41:1, 48:1, 56:1}, {25:1}, {16:1}, {34:1}, {32:1}, {21:1, 32:1}, {21:1, 32:1}, {21:1, 32:1}, {21:1, 32:1, 76:1}, {21:1, 26:1, 32:1}, {21:1, 32:1}, {17:1, 35:1}, {36:1}, {36:1}, {39:1, 41:1, 49:1, 56:1}, {50:1}, {43:1}, {42:1}, {39:1, 41:1, 51:1, 56:1}, {44:1}, {61:1}, {62:1}, {79:1}, {79:1}, {63:1}, {39:1, 40:1, 52:1}, {39:1, 40:1, 66:1}, {39:1, 40:1, 66:1}, {39:1, 40:1, 53:1}, {39:1, 40:1, 66:1}, {39:1, 60:1}, {39:1, 60:1}, {39:1, 60:1, 67:1}, {39:1, 60:1, 67:1}, {69:1}, {39:1, 60:1, 67:1}, {73:1}, {73:1}, {73:1}, {68:1, 71:1}, {37:1}, {54:1}, {37:1, 38:1, 54:1, 55:1}, {37:1, 38:1, 54:1, 55:1}, {37:1, 38:1, 54:1, 55:1}, {37:1, 38:1, 54:1, 55:1}, {39:1, 60:1, 67:1}, {37:1, 38:1, 54:1, 55:1}, {37:1, 38:1, 54:1, 55:1}, {37:1, 38:1, 54:1, 55:1}, {37:1, 38:1, 54:1, 55:1, 75:1}, {68:1, 71:1}, {37:1, 38:1, 54:1, 55:1, 75:1}, {37:1, 38:1, 54:1, 55:1}, {37:1, 38:1, 54:1, 55:1}, {72:1}, {39:1, 60:1, 67:1}, {39:1, 60:1, 67:1}, {39:1, 60:1, 67:1}, {39:1, 60:1, 67:1}, {39:1, 60:1}, {39:1, 60:1}, {39:1, 60:1, 65:1, 67:1}, {39:1, 58:1}, {39:1, 60:1, 67:1}, {39:1, 60:1, 67:1}, {39:1, 41:1, 57:1, 58:1}, {39:1, 60:1, 64:1, 67:1}, {39:1, 59:1}, {39:1, 60:1, 67:1}, {80:1}, {80:1}, {81:1}, {81:1}, {78:1}, {78:1}, {78:1}, {81:1}, {39:1, 40:1, 70:1, 79:1}, {79:1}, {80:1}, {81:1}, {81:1}, {78:1}, {79:1}, {39:1, 40:1, 77:1, 80:1}, {39:1, 40:1, 81:1}, {78:1}, {39:1, 60:1, 67:1}, {11:1}, {11:1}, {9:1, 11:1}, {11:1}, {9:1, 11:1}, {4:1, 11:1}, {9:1, 11:1}, {11:1}, {11:1}, {11:1}, {9:1, 11:1}, {11:1}, {11:1}, {11:1}, {9:1, 11:1}, {5:1, 11:1}, {11:1}, {9:1, 11:1}, {9:1, 10:1, 11:1}, {6:1, 9:1, 10:1, 11:1}, {11:1}, {11:1}, {11:1}, {11:1}, {7:1}, {29:1}, {8:1}, {9:1, 11:1}, {10:1, 11:1}, {11:1}, {9:1, 11:1}, {9:1, 11:1}, {9:1, 11:1}, {11:1}, {9:1, 11:1}, {9:1, 11:1, 74:1}, {11:1}, {11:1}, {11:1}, {11:1}, {11:1}, {11:1}, {11:1}, {11:1}];
function init(){
  !!$stats && $stats({moduleName:$moduleName, sessionId:$sessionId, subSystem:'startup', evtGroup:'moduleStartup', millis:(new Date).getTime(), type:'onModuleLoadStart', className:'com.spicesoft.o3d.test.client.JBHelloWorldEP'});
  $onModuleLoad($JBHelloWorldEP(new JBHelloWorldEP));
}

function caught_0(e){
  if (e != null && canCast(e.typeId$, 60)) {
    return e;
  }
  return $JavaScriptException(new JavaScriptException, e);
}

function add_5(a, b){
  var newHigh, newLow;
  newHigh = a[1] + b[1];
  newLow = a[0] + b[0];
  return create_15(newLow, newHigh);
}

function addTimes(accum, a, b){
  if (a == 0) {
    return accum;
  }
  if (b == 0) {
    return accum;
  }
  return add_5(accum, create_15(a * b, 0));
}

function compare_6(a, b){
  var nega, negb;
  if (a[0] == b[0] && a[1] == b[1]) {
    return 0;
  }
  nega = a[1] < 0;
  negb = b[1] < 0;
  if (nega && !negb) {
    return -1;
  }
  if (!nega && negb) {
    return 1;
  }
  if (sub(a, b)[1] < 0) {
    return -1;
  }
   else {
    return 1;
  }
}

function create_15(valueLow, valueHigh){
  var diffHigh, diffLow;
  valueHigh %= 1.8446744073709552E19;
  valueLow %= 1.8446744073709552E19;
  diffHigh = valueHigh % 4294967296;
  diffLow = Math.floor(valueLow / 4294967296) * 4294967296;
  valueHigh = valueHigh - diffHigh + diffLow;
  valueLow = valueLow - diffLow + diffHigh;
  while (valueLow < 0) {
    valueLow += 4294967296;
    valueHigh -= 4294967296;
  }
  while (valueLow > 4294967295) {
    valueLow -= 4294967296;
    valueHigh += 4294967296;
  }
  valueHigh = valueHigh % 1.8446744073709552E19;
  while (valueHigh > 9223372032559808512) {
    valueHigh -= 1.8446744073709552E19;
  }
  while (valueHigh < -9223372036854775808) {
    valueHigh += 1.8446744073709552E19;
  }
  return [valueLow, valueHigh];
}

function eq(a, b){
  return a[0] == b[0] && a[1] == b[1];
}

function fromDouble(value){
  if (isNaN(value)) {
    return $clinit_216() , ZERO;
  }
  if (value < -9223372036854775808) {
    return $clinit_216() , MIN_VALUE;
  }
  if (value >= 9223372036854775807) {
    return $clinit_216() , MAX_VALUE;
  }
  if (value > 0) {
    return create_15(Math.floor(value), 0);
  }
   else {
    return create_15(Math.ceil(value), 0);
  }
}

function fromInt(value){
  var rebase, result;
  if (value > -129 && value < 128) {
    rebase = value + 128;
    result = ($clinit_215() , boxedValues)[rebase];
    result == null && (result = boxedValues[rebase] = internalFromInt(value));
    return result;
  }
  return internalFromInt(value);
}

function internalFromInt(value){
  if (value >= 0) {
    return [value, 0];
  }
   else {
    return [value + 4294967296, -4294967296];
  }
}

function lowBits(a){
  if (a[0] >= 2147483648) {
    return ~~Math.max(Math.min(a[0] - 4294967296, 2147483647), -2147483648);
  }
   else {
    return ~~Math.max(Math.min(a[0], 2147483647), -2147483648);
  }
}

function mul_0(a, b){
  var a1, a2, a3, a4, b1, b2, b3, b4, res;
  if (a[0] == 0 && a[1] == 0) {
    return $clinit_216() , ZERO;
  }
  if (b[0] == 0 && b[1] == 0) {
    return $clinit_216() , ZERO;
  }
  if (eq(a, ($clinit_216() , MIN_VALUE))) {
    return multByMinValue(b);
  }
  if (eq(b, MIN_VALUE)) {
    return multByMinValue(a);
  }
  if (a[1] < 0) {
    if (b[1] < 0) {
      return mul_0(neg(a), neg(b));
    }
     else {
      return neg(mul_0(neg(a), b));
    }
  }
  if (b[1] < 0) {
    return neg(mul_0(a, neg(b)));
  }
  if (compare_6(a, TWO_PWR_24) < 0 && compare_6(b, TWO_PWR_24) < 0) {
    return create_15((a[1] + a[0]) * (b[1] + b[0]), 0);
  }
  a3 = a[1] % 281474976710656;
  a4 = a[1] - a3;
  a1 = a[0] % 65536;
  a2 = a[0] - a1;
  b3 = b[1] % 281474976710656;
  b4 = b[1] - b3;
  b1 = b[0] % 65536;
  b2 = b[0] - b1;
  res = ZERO;
  res = addTimes(res, a4, b1);
  res = addTimes(res, a3, b2);
  res = addTimes(res, a3, b1);
  res = addTimes(res, a2, b3);
  res = addTimes(res, a2, b2);
  res = addTimes(res, a2, b1);
  res = addTimes(res, a1, b4);
  res = addTimes(res, a1, b3);
  res = addTimes(res, a1, b2);
  res = addTimes(res, a1, b1);
  return res;
}

function multByMinValue(a){
  if ((lowBits(a) & 1) == 1) {
    return $clinit_216() , MIN_VALUE;
  }
   else {
    return $clinit_216() , ZERO;
  }
}

function neg(a){
  var newHigh, newLow;
  if (eq(a, ($clinit_216() , MIN_VALUE))) {
    return MIN_VALUE;
  }
  newHigh = -a[1];
  newLow = -a[0];
  if (newLow > 4294967295) {
    newLow -= 4294967296;
    newHigh += 4294967296;
  }
  if (newLow < 0) {
    newLow += 4294967296;
    newHigh -= 4294967296;
  }
  return [newLow, newHigh];
}

function sub(a, b){
  var newHigh, newLow;
  newHigh = a[1] - b[1];
  newLow = a[0] - b[0];
  return create_15(newLow, newHigh);
}

function $clinit_215(){
  $clinit_215 = nullMethod;
  boxedValues = initDim(_3_3D_classLit, 163, 7, 256, 0);
}

var boxedValues;
function $clinit_216(){
  $clinit_216 = nullMethod;
  Math.log(2);
  MAX_VALUE = P7fffffffffffffff_longLit;
  MIN_VALUE = N8000000000000000_longLit;
  fromInt(-1);
  fromInt(1);
  fromInt(2);
  TWO_PWR_24 = P1000000_longLit;
  ZERO = fromInt(0);
}

var MAX_VALUE, MIN_VALUE, TWO_PWR_24, ZERO;
function $CommandCanceledException(this$static){
  $fillInStackTrace();
  return this$static;
}

function getClass_153(){
  return Lcom_google_gwt_user_client_CommandCanceledException_2_classLit;
}

function CommandCanceledException(){
}

_ = CommandCanceledException.prototype = new RuntimeException;
_.getClass$ = getClass_153;
_.typeId$ = 70;
function $CommandExecutor(this$static){
  this$static.cancellationTimer = $CommandExecutor$1(new CommandExecutor$1, this$static);
  this$static.commands = $ArrayList(new ArrayList);
  this$static.executionTimer = $CommandExecutor$2(new CommandExecutor$2, this$static);
  this$static.iterator = $CommandExecutor$CircularIterator(new CommandExecutor$CircularIterator, this$static);
  return this$static;
}

function $doCommandCanceled(this$static){
  var cmd;
  cmd = $getLast(this$static.iterator);
  $remove_1(this$static.iterator);
  cmd != null && canCast(cmd.typeId$, 72) && $CommandCanceledException(new CommandCanceledException, dynamicCast(cmd, 72));
  this$static.executing = false;
  $maybeStartExecutionTimer(this$static);
}

function $doExecuteCommands(this$static, startTimeMillis){
  var command, element, wasCanceled;
  wasCanceled = false;
  try {
    this$static.executing = true;
    this$static.iterator.end = this$static.commands.size;
    $schedule(this$static.cancellationTimer, 10000);
    while ($hasNext(this$static.iterator)) {
      element = $next(this$static.iterator);
      try {
        if (element == null) {
          return;
        }
        if (element != null && canCast(element.typeId$, 72)) {
          command = dynamicCast(element, 72);
          $init_12(command.val$thisObj, 'o3d', false);
        }
      }
       finally {
        wasCanceled = this$static.iterator.last == -1;
        if (wasCanceled) {
          return;
        }
        $remove_1(this$static.iterator);
      }
      if ((new Date).getTime() - startTimeMillis >= 100) {
        return;
      }
    }
  }
   finally {
    if (!wasCanceled) {
      $cancel(this$static.cancellationTimer);
      this$static.executing = false;
      $maybeStartExecutionTimer(this$static);
    }
  }
}

function $maybeStartExecutionTimer(this$static){
  if (this$static.commands.size != 0 && !this$static.executionTimerPending && !this$static.executing) {
    this$static.executionTimerPending = true;
    $schedule(this$static.executionTimer, 1);
  }
}

function $submit(this$static, command){
  $add_7(this$static.commands, command);
  $maybeStartExecutionTimer(this$static);
}

function getClass_154(){
  return Lcom_google_gwt_user_client_CommandExecutor_2_classLit;
}

function CommandExecutor(){
}

_ = CommandExecutor.prototype = new Object_0;
_.getClass$ = getClass_154;
_.typeId$ = 0;
_.executing = false;
_.executionTimerPending = false;
function $clinit_222(){
  $clinit_222 = nullMethod;
  timers = $ArrayList(new ArrayList);
  addCloseHandler(new Timer$1);
}

function $cancel(this$static){
  this$static.isRepeating?($wnd.clearInterval(this$static.timerId) , undefined):($wnd.clearTimeout(this$static.timerId) , undefined);
  $remove_7(timers, this$static);
}

function $schedule(this$static, delayMillis){
  if (delayMillis <= 0) {
    throw $IllegalArgumentException(new IllegalArgumentException, 'must be positive');
  }
  $cancel(this$static);
  this$static.isRepeating = false;
  this$static.timerId = createTimeout(this$static, delayMillis);
  $add_7(timers, this$static);
}

function createTimeout(timer, delay){
  return $wnd.setTimeout($entry(function(){
    timer.fire();
  }
  ), delay);
}

function fire_0(){
  !this.isRepeating && $remove_7(timers, this);
  this.run();
}

function getClass_155(){
  return Lcom_google_gwt_user_client_Timer_2_classLit;
}

function Timer(){
}

_ = Timer.prototype = new Object_0;
_.fire = fire_0;
_.getClass$ = getClass_155;
_.typeId$ = 71;
_.isRepeating = false;
_.timerId = 0;
var timers;
function $clinit_223(){
  $clinit_223 = nullMethod;
  $clinit_222();
}

function $CommandExecutor$1(this$static, this$0){
  $clinit_223();
  this$static.this$0 = this$0;
  return this$static;
}

function getClass_156(){
  return Lcom_google_gwt_user_client_CommandExecutor$1_2_classLit;
}

function run(){
  if (!this.this$0.executing) {
    return;
  }
  $doCommandCanceled(this.this$0);
}

function CommandExecutor$1(){
}

_ = CommandExecutor$1.prototype = new Timer;
_.getClass$ = getClass_156;
_.run = run;
_.typeId$ = 72;
_.this$0 = null;
function $clinit_224(){
  $clinit_224 = nullMethod;
  $clinit_222();
}

function $CommandExecutor$2(this$static, this$0){
  $clinit_224();
  this$static.this$0 = this$0;
  return this$static;
}

function getClass_157(){
  return Lcom_google_gwt_user_client_CommandExecutor$2_2_classLit;
}

function run_0(){
  this.this$0.executionTimerPending = false;
  $doExecuteCommands(this.this$0, (new Date).getTime());
}

function CommandExecutor$2(){
}

_ = CommandExecutor$2.prototype = new Timer;
_.getClass$ = getClass_157;
_.run = run_0;
_.typeId$ = 73;
_.this$0 = null;
function $CommandExecutor$CircularIterator(this$static, this$0){
  this$static.this$0 = this$0;
  return this$static;
}

function $getLast(this$static){
  return $get_6(this$static.this$0.commands, this$static.last);
}

function $hasNext(this$static){
  return this$static.next < this$static.end;
}

function $next(this$static){
  var command;
  this$static.last = this$static.next;
  command = $get_6(this$static.this$0.commands, this$static.next++);
  this$static.next >= this$static.end && (this$static.next = 0);
  return command;
}

function $remove_1(this$static){
  $remove_6(this$static.this$0.commands, this$static.last);
  --this$static.end;
  this$static.last <= this$static.next && --this$static.next < 0 && (this$static.next = 0);
  this$static.last = -1;
}

function getClass_158(){
  return Lcom_google_gwt_user_client_CommandExecutor$CircularIterator_2_classLit;
}

function hasNext(){
  return this.next < this.end;
}

function next_0(){
  return $next(this);
}

function CommandExecutor$CircularIterator(){
}

_ = CommandExecutor$CircularIterator.prototype = new Object_0;
_.getClass$ = getClass_158;
_.hasNext = hasNext;
_.next_0 = next_0;
_.typeId$ = 0;
_.end = 0;
_.last = -1;
_.next = 0;
_.this$0 = null;
function dispatchEvent_0(evt, elem, listener){
  var prevCurrentEvent;
  prevCurrentEvent = currentEvent;
  currentEvent = evt;
  elem == sCaptureElem && $eventGetTypeInt(($clinit_178() , evt).type) == 8192 && (sCaptureElem = null);
  listener.onBrowserEvent(evt);
  currentEvent = prevCurrentEvent;
}

var currentEvent = null, sCaptureElem = null;
function $clinit_227(){
  $clinit_227 = nullMethod;
  commandExecutor = $CommandExecutor(new CommandExecutor);
}

function addCommand(cmd){
  $clinit_227();
  if (!cmd) {
    throw $NullPointerException_0(new NullPointerException, 'cmd cannot be null');
  }
  $submit(commandExecutor, cmd);
}

var commandExecutor;
function getClass_159(){
  return Lcom_google_gwt_user_client_Timer$1_2_classLit;
}

function onClose(event_0){
  while (($clinit_222() , timers).size > 0) {
    $cancel(dynamicCast($get_6(timers, 0), 73));
  }
}

function Timer$1(){
}

_ = Timer$1.prototype = new Object_0;
_.getClass$ = getClass_159;
_.onClose = onClose;
_.typeId$ = 74;
function addCloseHandler(handler){
  maybeInitializeCloseHandlers();
  return addHandler(TYPE?TYPE:(TYPE = $GwtEvent$Type(new GwtEvent$Type)), handler);
}

function addHandler(type, handler){
  return $addHandler(getHandlers(), type, handler);
}

function getHandlers(){
  !handlers && (handlers = $Window$WindowHandlers(new Window$WindowHandlers));
  return handlers;
}

function maybeInitializeCloseHandlers(){
  if (!closeHandlersInitialized) {
    $initWindowCloseHandler();
    closeHandlersInitialized = true;
  }
}

function onClosing(){
  var event_0;
  if (closeHandlersInitialized) {
    event_0 = ($clinit_231() , new Window$ClosingEvent);
    !!handlers && $fireEvent(handlers, event_0);
    return null;
  }
  return null;
}

var closeHandlersInitialized = false, handlers = null;
function $clinit_231(){
  $clinit_231 = nullMethod;
  TYPE_0 = $GwtEvent$Type(new GwtEvent$Type);
}

function dispatch_0(p0){
  throwClassCastExceptionUnlessNull(p0);
  null.nullMethod();
}

function getAssociatedType_0(){
  return TYPE_0;
}

function getClass_160(){
  return Lcom_google_gwt_user_client_Window$ClosingEvent_2_classLit;
}

function Window$ClosingEvent(){
}

_ = Window$ClosingEvent.prototype = new GwtEvent;
_.dispatch = dispatch_0;
_.getAssociatedType = getAssociatedType_0;
_.getClass$ = getClass_160;
_.typeId$ = 0;
var TYPE_0;
function $Window$WindowHandlers(this$static){
  this$static.registry = $HandlerManager$HandlerRegistry(new HandlerManager$HandlerRegistry);
  this$static.source = null;
  this$static.isReverseOrder = false;
  return this$static;
}

function getClass_161(){
  return Lcom_google_gwt_user_client_Window$WindowHandlers_2_classLit;
}

function Window$WindowHandlers(){
}

_ = Window$WindowHandlers.prototype = new HandlerManager;
_.getClass$ = getClass_161;
_.typeId$ = 75;
function $eventGetTypeInt(eventType){
  switch (eventType) {
    case 'blur':
      return 4096;
    case 'change':
      return 1024;
    case 'click':
      return 1;
    case 'dblclick':
      return 2;
    case 'focus':
      return 2048;
    case 'keydown':
      return 128;
    case 'keypress':
      return 256;
    case 'keyup':
      return 512;
    case 'load':
      return 32768;
    case 'losecapture':
      return 8192;
    case 'mousedown':
      return 4;
    case 'mousemove':
      return 64;
    case 'mouseout':
      return 32;
    case 'mouseover':
      return 16;
    case 'mouseup':
      return 8;
    case 'scroll':
      return 16384;
    case 'error':
      return 65536;
    case 'mousewheel':
      return 131072;
    case 'DOMMouseScroll':
      return 131072;
    case 'contextmenu':
      return 262144;
    case 'paste':
      return 524288;
  }
}

function $maybeInitializeEventSystem(){
  if (!eventSystemIsInitialized) {
    $initEventSystem();
    $initSyntheticMouseUpEvents();
    eventSystemIsInitialized = true;
  }
}

function isMyListener(object){
  return !(object != null && object.typeMarker$ != nullMethod && object.typeId$ != 2) && object != null && canCast(object.typeId$, 38);
}

var eventSystemIsInitialized = false;
--></script>
<script><!--
function $initEventSystem(){
  dispatchCapturedMouseEvent = $entry(function(evt){
    if (dispatchCapturedEvent(evt)) {
      var cap = captureElem;
      if (cap && cap.__listener) {
        if (isMyListener(cap.__listener)) {
          dispatchEvent_0(evt, cap, cap.__listener);
          evt.stopPropagation();
        }
      }
    }
  }
  );
  dispatchCapturedEvent = $entry(function(evt){
    return true;
  }
  );
  dispatchEvent_1 = $entry(function(evt){
    var listener, curElem = this;
    while (curElem && !(listener = curElem.__listener)) {
      curElem = curElem.parentNode;
    }
    curElem && curElem.nodeType != 1 && (curElem = null);
    listener && isMyListener(listener) && dispatchEvent_0(evt, curElem, listener);
  }
  );
  $wnd.addEventListener('click', dispatchCapturedMouseEvent, true);
  $wnd.addEventListener('dblclick', dispatchCapturedMouseEvent, true);
  $wnd.addEventListener('mousedown', dispatchCapturedMouseEvent, true);
  $wnd.addEventListener('mouseup', dispatchCapturedMouseEvent, true);
  $wnd.addEventListener('mousemove', dispatchCapturedMouseEvent, true);
  $wnd.addEventListener('mouseover', dispatchCapturedMouseEvent, true);
  $wnd.addEventListener('mouseout', dispatchCapturedMouseEvent, true);
  $wnd.addEventListener('mousewheel', dispatchCapturedMouseEvent, true);
  $wnd.addEventListener('keydown', dispatchCapturedEvent, true);
  $wnd.addEventListener('keyup', dispatchCapturedEvent, true);
  $wnd.addEventListener('keypress', dispatchCapturedEvent, true);
}

function $sinkEventsImpl(elem, bits){
  var chMask = (elem.__eventBits || 0) ^ bits;
  elem.__eventBits = bits;
  if (!chMask)
    return;
  chMask & 1 && (elem.onclick = bits & 1?dispatchEvent_1:null);
  chMask & 2 && (elem.ondblclick = bits & 2?dispatchEvent_1:null);
  chMask & 4 && (elem.onmousedown = bits & 4?dispatchEvent_1:null);
  chMask & 8 && (elem.onmouseup = bits & 8?dispatchEvent_1:null);
  chMask & 16 && (elem.onmouseover = bits & 16?dispatchEvent_1:null);
  chMask & 32 && (elem.onmouseout = bits & 32?dispatchEvent_1:null);
  chMask & 64 && (elem.onmousemove = bits & 64?dispatchEvent_1:null);
  chMask & 128 && (elem.onkeydown = bits & 128?dispatchEvent_1:null);
  chMask & 256 && (elem.onkeypress = bits & 256?dispatchEvent_1:null);
  chMask & 512 && (elem.onkeyup = bits & 512?dispatchEvent_1:null);
  chMask & 1024 && (elem.onchange = bits & 1024?dispatchEvent_1:null);
  chMask & 2048 && (elem.onfocus = bits & 2048?dispatchEvent_1:null);
  chMask & 4096 && (elem.onblur = bits & 4096?dispatchEvent_1:null);
  chMask & 8192 && (elem.onlosecapture = bits & 8192?dispatchEvent_1:null);
  chMask & 16384 && (elem.onscroll = bits & 16384?dispatchEvent_1:null);
  chMask & 32768 && (elem.onload = bits & 32768?dispatchEvent_1:null);
  chMask & 65536 && (elem.onerror = bits & 65536?dispatchEvent_1:null);
  chMask & 131072 && (elem.onmousewheel = bits & 131072?dispatchEvent_1:null);
  chMask & 262144 && (elem.oncontextmenu = bits & 262144?dispatchEvent_1:null);
  chMask & 524288 && (elem.onpaste = bits & 524288?dispatchEvent_1:null);
}

var captureElem = null, dispatchCapturedEvent = null, dispatchCapturedMouseEvent = null, dispatchEvent_1 = null;
function $initSyntheticMouseUpEvents(){
  $wnd.addEventListener('mouseout', $entry(function(evt){
    var cap = $wnd.__captureElem;
    if (cap && !evt.relatedTarget) {
      if ('html' == evt.target.tagName.toLowerCase()) {
        var muEvent = $doc.createEvent('MouseEvents');
        muEvent.initMouseEvent('mouseup', true, true, $wnd, 0, evt.screenX, evt.screenY, evt.clientX, evt.clientY, evt.ctrlKey, evt.altKey, evt.shiftKey, evt.metaKey, evt.button, null);
        cap.dispatchEvent(muEvent);
      }
    }
  }
  ), true);
  $wnd.addEventListener('DOMMouseScroll', dispatchCapturedMouseEvent, true);
}

function $sinkEvents(elem, bits){
  $maybeInitializeEventSystem();
  $sinkEventsImpl(elem, bits);
  bits & 131072 && elem.addEventListener('DOMMouseScroll', dispatchEvent_1, false);
}

function $initWindowCloseHandler(){
  var oldOnBeforeUnload = $wnd.onbeforeunload;
  var oldOnUnload = $wnd.onunload;
  $wnd.onbeforeunload = function(evt){
    var ret, oldRet;
    try {
      ret = $entry(onClosing)();
    }
     finally {
      oldRet = oldOnBeforeUnload && oldOnBeforeUnload(evt);
    }
    if (ret != null) {
      return ret;
    }
    if (oldRet != null) {
      return oldRet;
    }
  }
  ;
  $wnd.onunload = $entry(function(evt){
    try {
      closeHandlersInitialized && fire(getHandlers());
    }
     finally {
      oldOnUnload && oldOnUnload(evt);
      $wnd.onresize = null;
      $wnd.onscroll = null;
      $wnd.onbeforeunload = null;
      $wnd.onunload = null;
    }
  }
  );
}

function getClass_162(){
  return Lcom_google_gwt_user_client_ui_UIObject_2_classLit;
}

function toString_11(){
  if (!this.element) {
    return '(null handle)';
  }
  return $toString_1(($clinit_178() , this.element));
}

function UIObject(){
}

_ = UIObject.prototype = new Object_0;
_.getClass$ = getClass_162;
_.toString$ = toString_11;
_.typeId$ = 76;
_.element = null;
function $onAttach(this$static){
  var bitsToAdd;
  if (this$static.attached) {
    throw $IllegalStateException(new IllegalStateException, "Should only call onAttach when the widget is detached from the browser's document");
  }
  this$static.attached = true;
  this$static.element.__listener = this$static;
  bitsToAdd = this$static.eventsToSink;
  this$static.eventsToSink = -1;
  bitsToAdd > 0 && (this$static.eventsToSink == -1?$sinkEvents(this$static.element, bitsToAdd | (this$static.element.__eventBits || 0)):(this$static.eventsToSink |= bitsToAdd) , undefined);
  this$static.doAttachChildren();
  this$static.onLoad();
}

function $onDetach(this$static){
  if (!this$static.attached) {
    throw $IllegalStateException(new IllegalStateException, "Should only call onDetach when the widget is attached to the browser's document");
  }
  try {
    this$static.onUnload();
  }
   finally {
    try {
      this$static.doDetachChildren();
    }
     finally {
      this$static.element.__listener = null;
      this$static.attached = false;
    }
  }
}

function $removeFromParent(this$static){
  if (!this$static.parent_0) {
    $clinit_260();
    $containsKey(widgetsToDetach.map, this$static) && detachNow(this$static);
  }
   else if (this$static.parent_0) {
    this$static.parent_0.remove(this$static);
  }
   else if (this$static.parent_0) {
    throw $IllegalStateException(new IllegalStateException, "This widget's parent does not implement HasWidgets");
  }
}

function $setParent(this$static, parent_0){
  var oldParent;
  oldParent = this$static.parent_0;
  if (!parent_0) {
    try {
      !!oldParent && oldParent.attached && $onDetach(this$static);
    }
     finally {
      this$static.parent_0 = null;
    }
  }
   else {
    if (oldParent) {
      throw $IllegalStateException(new IllegalStateException, 'Cannot set a new parent without first clearing the old parent');
    }
    this$static.parent_0 = parent_0;
    parent_0.attached && $onAttach(this$static);
  }
}

function doAttachChildren(){
}

function doDetachChildren(){
}

function getClass_163(){
  return Lcom_google_gwt_user_client_ui_Widget_2_classLit;
}

function onBrowserEvent(event_0){
  var related;
  switch ($eventGetTypeInt(($clinit_178() , event_0).type)) {
    case 16:
    case 32:
      related = $eventGetRelatedTarget(event_0);
      if (!!related && $isOrHasChild(this.element, related)) {
        return;
      }

  }
}

function onLoad(){
}

function onUnload(){
}

function Widget(){
}

_ = Widget.prototype = new UIObject;
_.doAttachChildren = doAttachChildren;
_.doDetachChildren = doDetachChildren;
_.getClass$ = getClass_163;
_.onBrowserEvent = onBrowserEvent;
_.onLoad = onLoad;
_.onUnload = onUnload;
_.typeId$ = 77;
_.attached = false;
_.eventsToSink = 0;
_.parent_0 = null;
function doAttachChildren_0(){
  tryCommand(this, ($clinit_242() , attachCommand));
}

function doDetachChildren_0(){
  tryCommand(this, ($clinit_242() , detachCommand));
}

function getClass_164(){
  return Lcom_google_gwt_user_client_ui_Panel_2_classLit;
}

function onLoad_0(){
}

function onUnload_0(){
}

function Panel(){
}

_ = Panel.prototype = new Widget;
_.doAttachChildren = doAttachChildren_0;
_.doDetachChildren = doDetachChildren_0;
_.getClass$ = getClass_164;
_.onLoad = onLoad_0;
_.onUnload = onUnload_0;
_.typeId$ = 78;
function $add_3(this$static, child, container){
  $removeFromParent(child);
  $add_6(this$static.children, child);
  container.appendChild(child.element);
  $setParent(child, this$static);
}

function $remove_2(this$static, w){
  var elem, parent_0;
  if (w.parent_0 != this$static) {
    return false;
  }
  try {
    $setParent(w, null);
  }
   finally {
    elem = w.element;
    (parent_0 = ($clinit_178() , elem).parentNode , (!parent_0 || parent_0.nodeType != 1) && (parent_0 = null) , parent_0).removeChild(elem);
    $remove_4(this$static.children, w);
  }
  return true;
}

function getClass_165(){
  return Lcom_google_gwt_user_client_ui_ComplexPanel_2_classLit;
}

function iterator_0(){
  return $WidgetCollection$WidgetIterator(new WidgetCollection$WidgetIterator, this.children);
}

function remove(w){
  return $remove_2(this, w);
}

function ComplexPanel(){
}

_ = ComplexPanel.prototype = new Panel;
_.getClass$ = getClass_165;
_.iterator_0 = iterator_0;
_.remove = remove;
_.typeId$ = 79;
function $add_4(this$static, w){
  $add_3(this$static, w, this$static.element);
}

function changeToStaticPositioning(elem){
  elem.style['left'] = '';
  elem.style['top'] = '';
  elem.style['position'] = '';
}

function getClass_166(){
  return Lcom_google_gwt_user_client_ui_AbsolutePanel_2_classLit;
}

function remove_0(w){
  var removed;
  removed = $remove_2(this, w);
  removed && changeToStaticPositioning(w.element);
  return removed;
}

function AbsolutePanel(){
}

_ = AbsolutePanel.prototype = new ComplexPanel;
_.getClass$ = getClass_166;
_.remove = remove_0;
_.typeId$ = 80;
function $clinit_242(){
  $clinit_242 = nullMethod;
  attachCommand = new AttachDetachException$1;
  detachCommand = new AttachDetachException$2;
}

function $AttachDetachException(this$static, causes){
  $clinit_242();
  $Exception(this$static, 'One or more exceptions caught, see full set in AttachDetachException#getCauses', causes.map.size == 0?null:dynamicCast($toArray(causes, initDim(_3Ljava_lang_Throwable_2_classLit, 159, 60, 0, 0)), 74)[0]);
  return this$static;
}

function getClass_167(){
  return Lcom_google_gwt_user_client_ui_AttachDetachException_2_classLit;
}

function tryCommand(hasWidgets, c){
  var old;
  $clinit_242();
  var $e0, caught, e, w, w$iterator;
  caught = null;
  for (w$iterator = hasWidgets.iterator_0(); w$iterator.hasNext();) {
    w = dynamicCast(w$iterator.next_0(), 55);
    try {
      c.execute_0(w);
    }
     catch ($e0) {
      $e0 = caught_0($e0);
      if (instanceOf($e0, 60)) {
        e = $e0;
        !caught && (caught = $HashSet(new HashSet));
        old = $put(caught.map, e, caught);
      }
       else 
        throw $e0;
    }
  }
  if (caught) {
    throw $AttachDetachException(new AttachDetachException, caught);
  }
}

function AttachDetachException(){
}

_ = AttachDetachException.prototype = new RuntimeException;
_.getClass$ = getClass_167;
_.typeId$ = 81;
var attachCommand, detachCommand;
function execute_2(w){
  $onAttach(w);
}

function getClass_168(){
  return Lcom_google_gwt_user_client_ui_AttachDetachException$1_2_classLit;
}

function AttachDetachException$1(){
}

_ = AttachDetachException$1.prototype = new Object_0;
_.execute_0 = execute_2;
_.getClass$ = getClass_168;
_.typeId$ = 0;
function execute_3(w){
  $onDetach(w);
}

function getClass_169(){
  return Lcom_google_gwt_user_client_ui_AttachDetachException$2_2_classLit;
}

function AttachDetachException$2(){
}

_ = AttachDetachException$2.prototype = new Object_0;
_.execute_0 = execute_3;
_.getClass$ = getClass_169;
_.typeId$ = 0;
function getClass_170(){
  return Lcom_google_gwt_user_client_ui_CellPanel_2_classLit;
}

function CellPanel(){
}

_ = CellPanel.prototype = new ComplexPanel;
_.getClass$ = getClass_170;
_.typeId$ = 82;
_.body_0 = null;
_.table = null;
function $Label(this$static, element){
  this$static.element = element;
  return this$static;
}

function getClass_171(){
  return Lcom_google_gwt_user_client_ui_Label_2_classLit;
}

function Label(){
}

_ = Label.prototype = new Widget;
_.getClass$ = getClass_171;
_.typeId$ = 83;
function $HTML(this$static){
  $Label(this$static, ($clinit_178() , $doc).createElement('div'));
  this$static.element['className'] = 'gwt-HTML';
  return this$static;
}

function getClass_172(){
  return Lcom_google_gwt_user_client_ui_HTML_2_classLit;
}

function HTML(){
}

_ = HTML.prototype = new Label;
_.getClass$ = getClass_172;
_.typeId$ = 84;
function $clinit_251(){
  $clinit_251 = nullMethod;
  $HasHorizontalAlignment$HorizontalAlignmentConstant(new HasHorizontalAlignment$HorizontalAlignmentConstant, 'center');
  ALIGN_LEFT = $HasHorizontalAlignment$HorizontalAlignmentConstant(new HasHorizontalAlignment$HorizontalAlignmentConstant, 'left');
  $HasHorizontalAlignment$HorizontalAlignmentConstant(new HasHorizontalAlignment$HorizontalAlignmentConstant, 'right');
  ALIGN_DEFAULT = ALIGN_LEFT;
}

var ALIGN_DEFAULT, ALIGN_LEFT;
function $HasHorizontalAlignment$HorizontalAlignmentConstant(this$static, textAlignString){
  this$static.textAlignString = textAlignString;
  return this$static;
}

function getClass_173(){
  return Lcom_google_gwt_user_client_ui_HasHorizontalAlignment$HorizontalAlignmentConstant_2_classLit;
}

function HasHorizontalAlignment$HorizontalAlignmentConstant(){
}

_ = HasHorizontalAlignment$HorizontalAlignmentConstant.prototype = new Object_0;
_.getClass$ = getClass_173;
_.typeId$ = 0;
_.textAlignString = null;
function $clinit_254(){
  $clinit_254 = nullMethod;
  $HasVerticalAlignment$VerticalAlignmentConstant(new HasVerticalAlignment$VerticalAlignmentConstant, 'bottom');
  $HasVerticalAlignment$VerticalAlignmentConstant(new HasVerticalAlignment$VerticalAlignmentConstant, 'middle');
  ALIGN_TOP = $HasVerticalAlignment$VerticalAlignmentConstant(new HasVerticalAlignment$VerticalAlignmentConstant, 'top');
}

var ALIGN_TOP;
function $HasVerticalAlignment$VerticalAlignmentConstant(this$static, verticalAlignString){
  this$static.verticalAlignString = verticalAlignString;
  return this$static;
}

function getClass_174(){
  return Lcom_google_gwt_user_client_ui_HasVerticalAlignment$VerticalAlignmentConstant_2_classLit;
}

function HasVerticalAlignment$VerticalAlignmentConstant(){
}

_ = HasVerticalAlignment$VerticalAlignmentConstant.prototype = new Object_0;
_.getClass$ = getClass_174;
_.typeId$ = 0;
_.verticalAlignString = null;
function $clinit_260(){
  $clinit_260 = nullMethod;
  maybeDetachCommand = new RootPanel$1;
  rootPanels = $HashMap(new HashMap);
  widgetsToDetach = $HashSet(new HashSet);
}

function $RootPanel(this$static, elem){
  $clinit_260();
  this$static.children = $WidgetCollection(new WidgetCollection);
  this$static.element = elem;
  $onAttach(this$static);
  return this$static;
}

function detachNow(widget){
  $clinit_260();
  try {
    $onDetach(widget);
  }
   finally {
    $remove_5(widgetsToDetach.map, widget) != null;
  }
}

function detachWidgets(){
  $clinit_260();
  try {
    tryCommand(widgetsToDetach, maybeDetachCommand);
  }
   finally {
    $clearImpl(widgetsToDetach.map);
    $clearImpl(rootPanels);
  }
}

function get_3(id){
  $clinit_260();
  var elem, rp;
  rp = dynamicCast($get_5(rootPanels, id), 75);
  elem = null;
  if (id != null) {
    if (!(elem = $doc.getElementById(id))) {
      return null;
    }
  }
  if (rp) {
    if (!elem || rp.element == elem) {
      return rp;
    }
  }
  rootPanels.size == 0 && addCloseHandler(new RootPanel$2);
  !elem?(rp = $RootPanel$DefaultRootPanel(new RootPanel$DefaultRootPanel)):(rp = $RootPanel(new RootPanel, elem));
  $put(rootPanels, id, rp);
  $add_9(widgetsToDetach, rp);
  return rp;
}

function getClass_175(){
  return Lcom_google_gwt_user_client_ui_RootPanel_2_classLit;
}

function RootPanel(){
}

_ = RootPanel.prototype = new AbsolutePanel;
_.getClass$ = getClass_175;
_.typeId$ = 85;
var maybeDetachCommand, rootPanels, widgetsToDetach;
function execute_4(w){
  w.attached && $onDetach(w);
}

function getClass_176(){
  return Lcom_google_gwt_user_client_ui_RootPanel$1_2_classLit;
}

function RootPanel$1(){
}

_ = RootPanel$1.prototype = new Object_0;
_.execute_0 = execute_4;
_.getClass$ = getClass_176;
_.typeId$ = 0;
function getClass_177(){
  return Lcom_google_gwt_user_client_ui_RootPanel$2_2_classLit;
}

function onClose_0(closeEvent){
  detachWidgets();
}

function RootPanel$2(){
}

_ = RootPanel$2.prototype = new Object_0;
_.getClass$ = getClass_177;
_.onClose = onClose_0;
_.typeId$ = 86;
function $clinit_263(){
  $clinit_263 = nullMethod;
  $clinit_260();
}

function $RootPanel$DefaultRootPanel(this$static){
  $clinit_263();
  $RootPanel(this$static, $doc.body);
  return this$static;
}

function getClass_178(){
  return Lcom_google_gwt_user_client_ui_RootPanel$DefaultRootPanel_2_classLit;
}

function RootPanel$DefaultRootPanel(){
}

_ = RootPanel$DefaultRootPanel.prototype = new RootPanel;
_.getClass$ = getClass_178;
_.typeId$ = 87;
function $SimplePanel(this$static){
  $SimplePanel_0(this$static, ($clinit_178() , $doc).createElement('div'));
  return this$static;
}

function $SimplePanel_0(this$static, elem){
  this$static.element = elem;
  return this$static;
}

function getClass_179(){
  return Lcom_google_gwt_user_client_ui_SimplePanel_2_classLit;
}

function iterator_1(){
  return new SimplePanel$1;
}

function SimplePanel(){
}

_ = SimplePanel.prototype = new Panel;
_.getClass$ = getClass_179;
_.iterator_0 = iterator_1;
_.typeId$ = 88;
function $next_0(){
  throw $NoSuchElementException(new NoSuchElementException);
}

function getClass_180(){
  return Lcom_google_gwt_user_client_ui_SimplePanel$1_2_classLit;
}

function hasNext_0(){
  return false;
}

function next_1(){
  return $next_0();
}

function SimplePanel$1(){
}

_ = SimplePanel$1.prototype = new Object_0;
_.getClass$ = getClass_180;
_.hasNext = hasNext_0;
_.next_0 = next_1;
_.typeId$ = 0;
function $VerticalPanel(this$static){
  this$static.children = $WidgetCollection(new WidgetCollection);
  this$static.table = ($clinit_178() , $doc).createElement('table');
  this$static.body_0 = $doc.createElement('tbody');
  this$static.table.appendChild(this$static.body_0);
  this$static.element = this$static.table;
  this$static.horzAlign = ($clinit_251() , ALIGN_DEFAULT);
  this$static.vertAlign = ($clinit_254() , ALIGN_TOP);
  this$static.table['cellSpacing'] = '0';
  this$static.table['cellPadding'] = '0';
  return this$static;
}

function $add_5(this$static, w){
  var td, tr, td_0;
  tr = ($clinit_178() , $doc).createElement('tr');
  td = (td_0 = $doc.createElement('td') , td_0['align'] = this$static.horzAlign.textAlignString , td_0.style['verticalAlign'] = this$static.vertAlign.verticalAlignString , td_0);
  tr.appendChild(td);
  this$static.body_0.appendChild(tr);
  $removeFromParent(w);
  $add_6(this$static.children, w);
  td.appendChild(w.element);
  $setParent(w, this$static);
}

function getClass_181(){
  return Lcom_google_gwt_user_client_ui_VerticalPanel_2_classLit;
}

function remove_1(w){
  var removed, td, parent_0, parent_1;
  td = (parent_0 = ($clinit_178() , w.element).parentNode , (!parent_0 || parent_0.nodeType != 1) && (parent_0 = null) , parent_0);
  removed = $remove_2(this, w);
  removed && this.body_0.removeChild((parent_1 = td.parentNode , (!parent_1 || parent_1.nodeType != 1) && (parent_1 = null) , parent_1));
  return removed;
}

function VerticalPanel(){
}

_ = VerticalPanel.prototype = new CellPanel;
_.getClass$ = getClass_181;
_.remove = remove_1;
_.typeId$ = 89;
function $WidgetCollection(this$static){
  this$static.array = initDim(_3Lcom_google_gwt_user_client_ui_Widget_2_classLit, 147, 55, 4, 0);
  return this$static;
}

function $add_6(this$static, w){
  $insert(this$static, w, this$static.size);
}

function $indexOf_0(this$static, w){
  var i;
  for (i = 0; i < this$static.size; ++i) {
    if (this$static.array[i] == w) {
      return i;
    }
  }
  return -1;
}

function $insert(this$static, w, beforeIndex){
  var i, newArray;
  if (beforeIndex < 0 || beforeIndex > this$static.size) {
    throw $IndexOutOfBoundsException(new IndexOutOfBoundsException);
  }
  if (this$static.size == this$static.array.length) {
    newArray = initDim(_3Lcom_google_gwt_user_client_ui_Widget_2_classLit, 147, 55, this$static.array.length * 2, 0);
    for (i = 0; i < this$static.array.length; ++i) {
      setCheck(newArray, i, this$static.array[i]);
    }
    this$static.array = newArray;
  }
  ++this$static.size;
  for (i = this$static.size - 1; i > beforeIndex; --i) {
    setCheck(this$static.array, i, this$static.array[i - 1]);
  }
  setCheck(this$static.array, beforeIndex, w);
}

function $remove_3(this$static, index){
  var i;
  if (index < 0 || index >= this$static.size) {
    throw $IndexOutOfBoundsException(new IndexOutOfBoundsException);
  }
  --this$static.size;
  for (i = index; i < this$static.size; ++i) {
    setCheck(this$static.array, i, this$static.array[i + 1]);
  }
  setCheck(this$static.array, this$static.size, null);
}

function $remove_4(this$static, w){
  var index;
  index = $indexOf_0(this$static, w);
  if (index == -1) {
    throw $NoSuchElementException(new NoSuchElementException);
  }
  $remove_3(this$static, index);
}

function getClass_182(){
  return Lcom_google_gwt_user_client_ui_WidgetCollection_2_classLit;
}

function iterator_2(){
  return $WidgetCollection$WidgetIterator(new WidgetCollection$WidgetIterator, this);
}

function WidgetCollection(){
}

_ = WidgetCollection.prototype = new Object_0;
_.getClass$ = getClass_182;
_.iterator_0 = iterator_2;
_.typeId$ = 0;
_.array = null;
_.size = 0;
function $WidgetCollection$WidgetIterator(this$static, this$0){
  this$static.this$0 = this$0;
  return this$static;
}

function $next_1(this$static){
  if (this$static.index >= this$static.this$0.size) {
    throw $NoSuchElementException(new NoSuchElementException);
  }
  return this$static.this$0.array[++this$static.index];
}

function getClass_183(){
  return Lcom_google_gwt_user_client_ui_WidgetCollection$WidgetIterator_2_classLit;
}

function hasNext_1(){
  return this.index < this.this$0.size - 1;
}

function next_2(){
  return $next_1(this);
}

function WidgetCollection$WidgetIterator(){
}

_ = WidgetCollection$WidgetIterator.prototype = new Object_0;
_.getClass$ = getClass_183;
_.hasNext = hasNext_1;
_.next_0 = next_2;
_.typeId$ = 0;
_.index = -1;
_.this$0 = null;
function $JBHelloWorldEP(this$static){
  this$static.objectsMap = $HashMap(new HashMap);
  return this$static;
}

function $addObject(this$static, colShape, mass, origin){
  var body, dimentions, isDynamic, localInertia, myMotionState, rbInfo, startTransform, transform, shape, transform_0, shape_0, transform_1;
  $add_7(this$static.collisionShapes, colShape);
  startTransform = $Transform(new Transform);
  $setIdentity_0(startTransform.basis);
  $set_8(startTransform.origin, 0, 0, 0);
  isDynamic = mass != 0;
  localInertia = $Vector3f(new Vector3f, 0, 10, 0);
  isDynamic && colShape.calculateLocalInertia(mass, localInertia);
  $set_9(startTransform.origin, origin);
  myMotionState = $DefaultMotionState(new DefaultMotionState, startTransform);
  rbInfo = $RigidBodyConstructionInfo(new RigidBodyConstructionInfo, mass, myMotionState, colShape, localInertia);
  body = $RigidBody(new RigidBody, rbInfo);
  body.friction = 0.5;
  $addRigidBody(this$static.dynamicsWorld, body);
  transform = null;
  if (colShape != null && canCast(colShape.typeId$, 26)) {
    transform = (shape = $wnd.o3djs.primitives.createSphere($wnd.g_pack, $wnd.redMaterial, $getRadius(dynamicCast(colShape, 26)), 30, 10) , transform_0 = $wnd.g_pack.createObject('Transform') , transform_0.addShape(shape) , transform_0.translate([0, 0, 0]) , transform_0.parent = $wnd.o3dClient.root , transform_0);
  }
   else if (colShape != null && canCast(colShape.typeId$, 76)) {
    dimentions = $Vector3f_2(new Vector3f);
    $getHalfExtentsWithMargin(dynamicCast(colShape, 76), dimentions);
    transform = (shape_0 = $wnd.o3djs.primitives.createBox($wnd.g_pack, $wnd.redMaterial, dimentions.x * 2, dimentions.y * 2, dimentions.z * 2) , transform_1 = $wnd.g_pack.createObject('Transform') , transform_1.addShape(shape_0) , transform_1.translate([0, 0, 0]) , transform_1.parent = $wnd.o3dClient.root , transform_1);
  }
  $put(this$static.objectsMap, valueOf(body.debugBodyId), transform);
}

function $init_12(x, id, useV8){
  useV8 && $wnd.o3djs.util.setMainEngine($wnd.o3djs.util.Engine.V8);
  $wnd.o3djs.util.makeClients(function(clientElements){
    var o3dElement = clientElements[0];
    var g_client = o3dElement.client;
    $wnd.cycle = 0;
    x.initCallback(o3dElement, g_client);
    g_client.setRenderCallback(function(re){
      x.renderCallback(re, re.elapsedTime);
    }
    );
  }
  , null, null, id);
}

function $lala(x, clientElement, client){
  var g_pack = client.createPack();
  $wnd.g_pack = g_pack;
  var g_math = $wnd.o3djs.math;
  $wnd.g_math = g_math;
  $wnd.o3dClient = client;
  var viewInfo = $wnd.o3djs.rendergraph.createBasicView(g_pack, client.root, client.renderGraphRoot);
  $wnd.o3djs.event.addEventListener(clientElement, 'mousedown', function(){
    x.spawnNewObject();
  }
  );
  $wnd.viewInfo = viewInfo;
  var redMaterial = g_pack.createObject('Material');
  var g_lightPosition = [0, 40, 0];
  $wnd.o3djs.effect.attachStandardShader(g_pack, redMaterial, g_lightPosition, 'phong');
  redMaterial.drawList = viewInfo.performanceDrawList;
  redMaterial.getParam('emissive').value = [0, 0, 0, 1];
  redMaterial.getParam('ambient').value = g_math.mul(0.1, [1, 0, 0, 1]);
  redMaterial.getParam('diffuse').value = g_math.mul(0.9, [1, 0, 0, 1]);
  redMaterial.getParam('specular').value = [0.2, 0.2, 0.2, 1];
  redMaterial.getParam('shininess').value = 20;
  $wnd.redMaterial = redMaterial;
  var blueMaterial = g_pack.createObject('Material');
  var g_lightPosition = [5, 5, 7];
  $wnd.o3djs.effect.attachStandardShader(g_pack, blueMaterial, g_lightPosition, 'phong');
  blueMaterial.drawList = viewInfo.performanceDrawList;
  blueMaterial.getParam('emissive').value = [0, 0, 0, 1];
  blueMaterial.getParam('ambient').value = g_math.mul(0.1, [0, 1, 0, 1]);
  blueMaterial.getParam('diffuse').value = g_math.mul(0.9, [0, 1, 0, 1]);
  blueMaterial.getParam('specular').value = [0.2, 0.2, 0.2, 1];
  blueMaterial.getParam('shininess').value = 20;
  $wnd.blueMaterial = blueMaterial;
  var ground1 = $wnd.o3djs.primitives.createBox(g_pack, blueMaterial, 20, 2, 20);
  var ground2 = $wnd.o3djs.primitives.createBox(g_pack, blueMaterial, 60, 2, 60);
  var groundTransform1 = g_pack.createObject('Transform');
  groundTransform1.addShape(ground1);
  groundTransform1.translate([0, -1, 0]);
  groundTransform1.parent = client.root;
  var groundTransform2 = g_pack.createObject('Transform');
  groundTransform2.addShape(ground2);
  groundTransform2.translate([0, -9, 0]);
  groundTransform2.parent = client.root;
  viewInfo.drawContext.projection = g_math.matrix4.perspective(g_math.degToRad(30), clientElement.clientWidth / clientElement.clientHeight, 1, 5000);
  var eye = [100, 30, 100];
  var target = [0, 0, 0];
  var up = [0, 1, 0];
  viewInfo.drawContext.view = g_math.matrix4.lookAt(eye, target, up);
}

function $onModuleLoad(this$static){
  var sp, thisObj, vp;
  sp = $SimplePanel(new SimplePanel);
  sp.element.style['width'] = '640px';
  sp.element.style['height'] = '480px';
  sp.element.setAttribute('id', 'o3d');
  vp = $VerticalPanel(new VerticalPanel);
  $add_5(vp, sp);
  this$static.debugHTML = $HTML(new HTML);
  this$static.debugHTML.element.innerHTML = 'Click to spawn new objects.';
  this$static.debugHTML.element.setAttribute('id', 'debug');
  $add_5(vp, this$static.debugHTML);
  $add_4(get_3('main'), vp);
  thisObj = this$static;
  addCommand($JBHelloWorldEP$1(new JBHelloWorldEP$1, thisObj));
}

function getClass_184(){
  return Lcom_spicesoft_o3d_test_client_JBHelloWorldEP_2_classLit;
}

--></script>
<script><!--
function initCallback(clientElement, client){
  var body, collisionConfiguration, dispatcher, groundShape, groundTransform, localInertia, myMotionState, overlappingPairCache, rbInfo, solver, worldAabbMax, worldAabbMin;
  $lala(this, clientElement, client);
  collisionConfiguration = $DefaultCollisionConfiguration(new DefaultCollisionConfiguration);
  dispatcher = $CollisionDispatcher(new CollisionDispatcher, collisionConfiguration);
  worldAabbMin = $Vector3f(new Vector3f, -100, -100, -100);
  worldAabbMax = $Vector3f(new Vector3f, 100, 100, 100);
  overlappingPairCache = $AxisSweep3(new AxisSweep3, worldAabbMin, worldAabbMax, 1024);
  solver = $SequentialImpulseConstraintSolver(new SequentialImpulseConstraintSolver);
  this.dynamicsWorld = $DiscreteDynamicsWorld(new DiscreteDynamicsWorld, dispatcher, overlappingPairCache, solver);
  $setGravity(this.dynamicsWorld, $Vector3f(new Vector3f, 0, -30, 0));
  this.collisionShapes = $ArrayList(new ArrayList);
  groundShape = $BoxShape(new BoxShape, $Vector3f(new Vector3f, 10, 1, 10));
  $add_7(this.collisionShapes, groundShape);
  groundTransform = $Transform(new Transform);
  $setIdentity_0(groundTransform.basis);
  $set_8(groundTransform.origin, 0, 0, 0);
  $set_9(groundTransform.origin, $Vector3f(new Vector3f, 0, -1, 0));
  localInertia = $Vector3f(new Vector3f, 0, 10, 0);
  myMotionState = $DefaultMotionState(new DefaultMotionState, groundTransform);
  rbInfo = $RigidBodyConstructionInfo(new RigidBodyConstructionInfo, 0, myMotionState, groundShape, localInertia);
  body = $RigidBody(new RigidBody, rbInfo);
  body.friction = 0.5;
  $addRigidBody(this.dynamicsWorld, body);
  groundShape = $BoxShape(new BoxShape, $Vector3f(new Vector3f, 30, 1, 30));
  $add_7(this.collisionShapes, groundShape);
  groundTransform = $Transform(new Transform);
  $setIdentity_0(groundTransform.basis);
  $set_8(groundTransform.origin, 0, 0, 0);
  $set_9(groundTransform.origin, $Vector3f(new Vector3f, 0, -9, 0));
  localInertia = $Vector3f(new Vector3f, 0, 0, 0);
  myMotionState = $DefaultMotionState(new DefaultMotionState, groundTransform);
  rbInfo = $RigidBodyConstructionInfo(new RigidBodyConstructionInfo, 0, myMotionState, groundShape, localInertia);
  body = $RigidBody(new RigidBody, rbInfo);
  body.friction = 0.5;
  $addRigidBody(this.dynamicsWorld, body);
  $addObject(this, $BoxShape(new BoxShape, $Vector3f_0(new Vector3f, initValues(_3F_classLit, 149, -1, [0.5, 5, 0.5]))), 2, $Vector3f_0(new Vector3f, initValues(_3F_classLit, 149, -1, [-4, 5, -4])));
  $addObject(this, $BoxShape(new BoxShape, $Vector3f_0(new Vector3f, initValues(_3F_classLit, 149, -1, [0.5, 5, 0.5]))), 2, $Vector3f_0(new Vector3f, initValues(_3F_classLit, 149, -1, [4, 5, -4])));
  $addObject(this, $BoxShape(new BoxShape, $Vector3f_0(new Vector3f, initValues(_3F_classLit, 149, -1, [0.5, 5, 0.5]))), 2, $Vector3f_0(new Vector3f, initValues(_3F_classLit, 149, -1, [-4, 5, 4])));
  $addObject(this, $BoxShape(new BoxShape, $Vector3f_0(new Vector3f, initValues(_3F_classLit, 149, -1, [0.5, 5, 0.5]))), 2, $Vector3f_0(new Vector3f, initValues(_3F_classLit, 149, -1, [4, 5, 4])));
  $addObject(this, $BoxShape(new BoxShape, $Vector3f_0(new Vector3f, initValues(_3F_classLit, 149, -1, [8, 0.5, 8]))), 1, $Vector3f_0(new Vector3f, initValues(_3F_classLit, 149, -1, [0, 10, 0])));
}

function renderCallback_0(renderCallback, elapsedTime){
  var body, j, localmatrix, obj, trans, eye, target, up;
  this.cycle_0 = (this.cycle_0 + elapsedTime / 5) % 360;
  $stepSimulation(this.dynamicsWorld, elapsedTime * 1.2000000476837158, 2, 0.01666666753590107);
  for (j = 0; j < this.dynamicsWorld.collisionObjects.size; ++j) {
    obj = dynamicCast($get_6(this.dynamicsWorld.collisionObjects, j), 17);
    body = upcast(obj);
    if (!!body && !!body.optionalMotionState) {
      trans = $Transform(new Transform);
      $getWorldTransform_0(body.optionalMotionState, trans);
      localmatrix = initDim(_3F_classLit, 149, -1, 16, 1);
      getOpenGLSubMatrix(trans.basis, localmatrix);
      localmatrix[12] = trans.origin.x;
      localmatrix[13] = trans.origin.y;
      localmatrix[14] = trans.origin.z;
      localmatrix[15] = 1;
      $get_5(this.objectsMap, valueOf(body.debugBodyId)) != null && (dynamicCastJso($get_5(this.objectsMap, valueOf(body.debugBodyId))).localMatrix = [[localmatrix[0], localmatrix[1], localmatrix[2], localmatrix[3]], [localmatrix[4], localmatrix[5], localmatrix[6], localmatrix[7]], [localmatrix[8], localmatrix[9], localmatrix[10], localmatrix[11]], [localmatrix[12], localmatrix[13], localmatrix[14], localmatrix[15]]] , undefined);
    }
  }
  eye = [10 + 70 * Math.sin(this.cycle_0), 30 + 20 * Math.cos(this.cycle_0 * 3), 20 + 70 * Math.cos(this.cycle_0)];
  target = [0, 0, 0];
  up = [0, 1, 0];
  $wnd.viewInfo.drawContext.view = $wnd.g_math.matrix4.lookAt(eye, target, up);
}

function spawnNewObject(){
  var origin;
  origin = $Vector3f_0(new Vector3f, initValues(_3F_classLit, 149, -1, [7 - 14 * Math.random(), 30 + 20 * Math.random(), 7 - 14 * Math.random()]));
  round_int(10 * Math.random()) % 2 == 0?$addObject(this, $SphereShape(new SphereShape, 1), 1, origin):$addObject(this, $BoxShape(new BoxShape, $Vector3f_0(new Vector3f, initValues(_3F_classLit, 149, -1, [0.5, 0.5, 0.5]))), 0.5, origin);
}

function JBHelloWorldEP(){
}

_ = JBHelloWorldEP.prototype = new Object_0;
_.getClass$ = getClass_184;
_.initCallback = initCallback;
_.renderCallback = renderCallback_0;
_.spawnNewObject = spawnNewObject;
_.typeId$ = 0;
_.collisionShapes = null;
_.cycle_0 = 0;
_.debugHTML = null;
_.dynamicsWorld = null;
function $JBHelloWorldEP$1(this$static, val$thisObj){
  this$static.val$thisObj = val$thisObj;
  return this$static;
}

function getClass_185(){
  return Lcom_spicesoft_o3d_test_client_JBHelloWorldEP$1_2_classLit;
}

function JBHelloWorldEP$1(){
}

_ = JBHelloWorldEP$1.prototype = new Object_0;
_.getClass$ = getClass_185;
_.typeId$ = 90;
_.val$thisObj = null;
function $IndexOutOfBoundsException(this$static){
  $fillInStackTrace();
  return this$static;
}

function $IndexOutOfBoundsException_0(this$static, message){
  $fillInStackTrace();
  this$static.detailMessage = message;
  return this$static;
}

function getClass_186(){
  return Ljava_lang_IndexOutOfBoundsException_2_classLit;
}

function IndexOutOfBoundsException(){
}

_ = IndexOutOfBoundsException.prototype = new RuntimeException;
_.getClass$ = getClass_186;
_.typeId$ = 92;
function $ArrayIndexOutOfBoundsException(this$static, msg){
  $fillInStackTrace();
  this$static.detailMessage = msg;
  return this$static;
}

function getClass_187(){
  return Ljava_lang_ArrayIndexOutOfBoundsException_2_classLit;
}

function ArrayIndexOutOfBoundsException(){
}

_ = ArrayIndexOutOfBoundsException.prototype = new IndexOutOfBoundsException;
_.getClass$ = getClass_187;
_.typeId$ = 93;
function $ArrayStoreException(this$static){
  $fillInStackTrace();
  return this$static;
}

function $ArrayStoreException_0(this$static, message){
  $fillInStackTrace();
  this$static.detailMessage = message;
  return this$static;
}

function getClass_188(){
  return Ljava_lang_ArrayStoreException_2_classLit;
}

function ArrayStoreException(){
}

_ = ArrayStoreException.prototype = new RuntimeException;
_.getClass$ = getClass_188;
_.typeId$ = 94;
function createForArray(packageName, className, componentType){
  var clazz;
  clazz = new Class;
  clazz.typeName = packageName + className;
  clazz.modifiers = 4;
  clazz.componentType = componentType;
  return clazz;
}

function createForClass(packageName, className){
  var clazz;
  clazz = new Class;
  clazz.typeName = packageName + className;
  return clazz;
}

function createForEnum(packageName, className, enumConstantsFunc){
  var clazz;
  clazz = new Class;
  clazz.typeName = packageName + className;
  clazz.modifiers = enumConstantsFunc?8:0;
  return clazz;
}

function createForInterface(packageName, className){
  var clazz;
  clazz = new Class;
  clazz.typeName = packageName + className;
  clazz.modifiers = 2;
  return clazz;
}

function createForPrimitive(packageName, className){
  var clazz;
  clazz = new Class;
  clazz.typeName = packageName + className;
  clazz.modifiers = 1;
  return clazz;
}

function getClass_189(){
  return Ljava_lang_Class_2_classLit;
}

function toString_12(){
  return ((this.modifiers & 2) != 0?'interface ':(this.modifiers & 1) != 0?'':'class ') + this.typeName;
}

function Class(){
}

_ = Class.prototype = new Object_0;
_.getClass$ = getClass_189;
_.toString$ = toString_12;
_.typeId$ = 0;
_.componentType = null;
_.modifiers = 0;
_.typeName = null;
function $ClassCastException(this$static){
  $fillInStackTrace();
  return this$static;
}

function getClass_190(){
  return Ljava_lang_ClassCastException_2_classLit;
}

function ClassCastException(){
}

_ = ClassCastException.prototype = new RuntimeException;
_.getClass$ = getClass_190;
_.typeId$ = 97;
function getClass_191(){
  return Ljava_lang_Number_2_classLit;
}

function Number_0(){
}

_ = Number_0.prototype = new Object_0;
_.getClass$ = getClass_191;
_.typeId$ = 98;
function $IllegalArgumentException(this$static, message){
  $fillInStackTrace();
  this$static.detailMessage = message;
  return this$static;
}

function getClass_192(){
  return Ljava_lang_IllegalArgumentException_2_classLit;
}

function IllegalArgumentException(){
}

_ = IllegalArgumentException.prototype = new RuntimeException;
_.getClass$ = getClass_192;
_.typeId$ = 99;
function $IllegalStateException(this$static, s){
  $fillInStackTrace();
  this$static.detailMessage = s;
  return this$static;
}

function getClass_193(){
  return Ljava_lang_IllegalStateException_2_classLit;
}

function IllegalStateException(){
}

_ = IllegalStateException.prototype = new RuntimeException;
_.getClass$ = getClass_193;
_.typeId$ = 100;
function $Integer(this$static, value){
  this$static.value_0 = value;
  return this$static;
}

function $compareTo_0(this$static, b){
  if (this$static.value_0 < b.value_0) {
    return -1;
  }
   else if (this$static.value_0 > b.value_0) {
    return 1;
  }
   else {
    return 0;
  }
}

function compareTo_0(p0){
  return $compareTo_0(this, dynamicCast(p0, 57));
}

function equals_7(o){
  return o != null && canCast(o.typeId$, 57) && dynamicCast(o, 57).value_0 == this.value_0;
}

function getClass_194(){
  return Ljava_lang_Integer_2_classLit;
}

function hashCode_9(){
  return this.value_0;
}

function toPowerOfTwoString(value, shift){
  var bitMask, buf, bufSize, digits, pos;
  bufSize = ~~(32 / shift);
  bitMask = (1 << shift) - 1;
  buf = initDim(_3C_classLit, 0, -1, bufSize, 1);
  digits = ($clinit_292() , digits_0);
  pos = bufSize - 1;
  if (value >= 0) {
    while (value > bitMask) {
      buf[pos--] = digits[value & bitMask];
      value >>= shift;
    }
  }
   else {
    while (pos > 0) {
      buf[pos--] = digits[value & bitMask];
      value >>= shift;
    }
  }
  buf[pos] = digits[value & bitMask];
  return __valueOf(buf, pos, bufSize);
}

function toString_13(){
  return '' + this.value_0;
}

function valueOf(i){
  var rebase, result;
  if (i > -129 && i < 128) {
    rebase = i + 128;
    result = ($clinit_288() , boxedValues_0)[rebase];
    !result && (result = boxedValues_0[rebase] = $Integer(new Integer, i));
    return result;
  }
  return $Integer(new Integer, i);
}

function Integer(){
}

_ = Integer.prototype = new Number_0;
_.compareTo$ = compareTo_0;
_.equals$ = equals_7;
_.getClass$ = getClass_194;
_.hashCode$ = hashCode_9;
_.toString$ = toString_13;
_.typeId$ = 101;
_.value_0 = 0;
function $clinit_288(){
  $clinit_288 = nullMethod;
  boxedValues_0 = initDim(_3Ljava_lang_Integer_2_classLit, 155, 57, 256, 0);
}

var boxedValues_0;
function abs(x){
  return x < 0?-x:x;
}

function max_0(x, y){
  return x > y?x:y;
}

function min_0(x, y){
  return x < y?x:y;
}

function $NullPointerException(this$static){
  $fillInStackTrace();
  return this$static;
}

function $NullPointerException_0(this$static, message){
  $fillInStackTrace();
  this$static.detailMessage = message;
  return this$static;
}

function getClass_195(){
  return Ljava_lang_NullPointerException_2_classLit;
}

function NullPointerException(){
}

_ = NullPointerException.prototype = new RuntimeException;
_.getClass$ = getClass_195;
_.typeId$ = 102;
function $clinit_292(){
  $clinit_292 = nullMethod;
  digits_0 = initValues(_3C_classLit, 0, -1, [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122]);
}

var digits_0;
function $StackTraceElement(this$static, className, methodName, fileName, lineNumber){
  this$static.className = className;
  this$static.methodName = methodName;
  this$static.fileName = fileName;
  this$static.lineNumber = lineNumber;
  return this$static;
}

function getClass_196(){
  return Ljava_lang_StackTraceElement_2_classLit;
}

function toString_14(){
  return this.className + '.' + this.methodName + '(' + this.fileName + ':' + this.lineNumber + ')';
}

function StackTraceElement(){
}

_ = StackTraceElement.prototype = new Object_0;
_.getClass$ = getClass_196;
_.toString$ = toString_14;
_.typeId$ = 103;
_.className = null;
_.fileName = null;
_.lineNumber = 0;
_.methodName = null;
function $trim(this$static){
  if (this$static.length == 0 || this$static[0] > ' ' && this$static[this$static.length - 1] > ' ') {
    return this$static;
  }
  var r1 = this$static.replace(/^(\s*)/, '');
  var r2 = r1.replace(/\s*$/, '');
  return r2;
}

function __valueOf(x, start, end){
  x = x.slice(start, end);
  return String.fromCharCode.apply(null, x);
}

function compareTo_1(thisStr, otherStr){
  thisStr = String(thisStr);
  if (thisStr == otherStr) {
    return 0;
  }
  return thisStr < otherStr?-1:1;
}

function compareTo_2(p0){
  return compareTo_1(this, dynamicCast(p0, 1));
}

function equals_8(other){
  if (!(other != null && canCast(other.typeId$, 1))) {
    return false;
  }
  return String(this) == other;
}

function getClass_197(){
  return Ljava_lang_String_2_classLit;
}

function hashCode_10(){
  return getHashCode_0(this);
}

function toString_15(){
  return this;
}

_ = String.prototype;
_.compareTo$ = compareTo_2;
_.equals$ = equals_8;
_.getClass$ = getClass_197;
_.hashCode$ = hashCode_10;
_.toString$ = toString_15;
_.typeId$ = 2;
function $clinit_295(){
  $clinit_295 = nullMethod;
  back = {};
  front = {};
}

function compute(str){
  var hashCode, i, n, nBatch;
  hashCode = 0;
  n = str.length;
  nBatch = n - 4;
  i = 0;
  while (i < nBatch) {
    hashCode = str.charCodeAt(i + 3) + 31 * (str.charCodeAt(i + 2) + 31 * (str.charCodeAt(i + 1) + 31 * (str.charCodeAt(i) + 31 * hashCode))) | 0;
    i += 4;
  }
  while (i < n) {
    hashCode = hashCode * 31 + str.charCodeAt(i++);
  }
  return hashCode | 0;
}

function getHashCode_0(str){
  $clinit_295();
  var key = ':' + str;
  var result = front[key];
  if (result != null) {
    return result;
  }
  result = back[key];
  result == null && (result = compute(str));
  increment();
  return front[key] = result;
}

function increment(){
  if (count_0 == 256) {
    back = front;
    front = {};
    count_0 = 0;
  }
  ++count_0;
}

var back, count_0 = 0, front;
function $StringBuffer(this$static){
  this$static.impl = new StringBufferImplAppend;
  return this$static;
}

function $append_0(this$static, x){
  this$static.impl.string += x;
  return this$static;
}

function getClass_198(){
  return Ljava_lang_StringBuffer_2_classLit;
}

function toString_16(){
  return this.impl.string;
}

function StringBuffer(){
}

_ = StringBuffer.prototype = new Object_0;
_.getClass$ = getClass_198;
_.toString$ = toString_16;
_.typeId$ = 0;
function arraycopy(src, srcOfs, dest, destOfs, len){
  var destArray, destComp, destEnd, destType, destlen, srcArray, srcComp, srcType, srclen;
  if (src == null || dest == null) {
    throw $NullPointerException(new NullPointerException);
  }
  srcType = src.typeMarker$ == nullMethod || src.typeId$ == 2?src.getClass$():Lcom_google_gwt_core_client_JavaScriptObject_2_classLit;
  destType = dest.typeMarker$ == nullMethod || dest.typeId$ == 2?dest.getClass$():Lcom_google_gwt_core_client_JavaScriptObject_2_classLit;
  if ((srcType.modifiers & 4) == 0 || (destType.modifiers & 4) == 0) {
    throw $ArrayStoreException_0(new ArrayStoreException, 'Must be array types');
  }
  srcComp = srcType.componentType;
  destComp = destType.componentType;
  if (srcComp.modifiers != destComp.modifiers || (srcComp.modifiers & 1) != 0 && srcComp != destComp) {
    throw $ArrayStoreException_0(new ArrayStoreException, 'Array types must match');
  }
  srclen = src.length;
  destlen = dest.length;
  if (srcOfs < 0 || destOfs < 0 || len < 0 || srcOfs + len > srclen || destOfs + len > destlen) {
    throw $IndexOutOfBoundsException(new IndexOutOfBoundsException);
  }
  if (((srcComp.modifiers & 1) == 0 || (srcComp.modifiers & 4) != 0) && srcType != destType) {
    srcArray = dynamicCast(src, 11);
    destArray = dynamicCast(dest, 11);
    if ((src == null?null:src) === (dest == null?null:dest) && srcOfs < destOfs) {
      srcOfs += len;
      for (destEnd = destOfs + len; destEnd-- > destOfs;) {
        setCheck(destArray, destEnd, srcArray[--srcOfs]);
      }
    }
     else {
      for (destEnd = destOfs + len; destOfs < destEnd;) {
        setCheck(destArray, destOfs++, srcArray[srcOfs++]);
      }
    }
  }
   else {
    Array.prototype.splice.apply(dest, [destOfs, len].concat(src.slice(srcOfs, srcOfs + len)));
  }
}

function $UnsupportedOperationException(this$static){
  $fillInStackTrace();
  return this$static;
}

function $UnsupportedOperationException_0(this$static, message){
  $fillInStackTrace();
  this$static.detailMessage = message;
  return this$static;
}

function getClass_199(){
  return Ljava_lang_UnsupportedOperationException_2_classLit;
}

function UnsupportedOperationException(){
}

_ = UnsupportedOperationException.prototype = new RuntimeException;
_.getClass$ = getClass_199;
_.typeId$ = 104;
function $equals_4(this$static, obj){
  var entry, entry$iterator, otherKey, otherMap, otherValue;
  if ((obj == null?null:obj) === (this$static == null?null:this$static)) {
    return true;
  }
  if (!(obj != null && canCast(obj.typeId$, 80))) {
    return false;
  }
  otherMap = dynamicCast(obj, 80);
  if (this$static.size != otherMap.size_0()) {
    return false;
  }
  for (entry$iterator = otherMap.entrySet_0().iterator_0(); entry$iterator.hasNext();) {
    entry = dynamicCast(entry$iterator.next_0(), 78);
    otherKey = entry.getKey();
    otherValue = entry.getValue();
    if (!(otherKey == null?this$static.nullSlotLive:otherKey != null && canCast(otherKey.typeId$, 1)?$hasStringValue(this$static, dynamicCast(otherKey, 1)):$hasHashValue(this$static, otherKey, ~~hashCode__devirtual$(otherKey)))) {
      return false;
    }
    if (!equalsWithNullCheck(otherValue, otherKey == null?this$static.nullSlot:otherKey != null && canCast(otherKey.typeId$, 1)?this$static.stringMap[':' + dynamicCast(otherKey, 1)]:$getHashValue(this$static, otherKey, ~~hashCode__devirtual$(otherKey)))) {
      return false;
    }
  }
  return true;
}

function $hashCode_4(this$static){
  var entry, entry$iterator, hashCode;
  hashCode = 0;
  for (entry$iterator = $AbstractHashMap$EntrySetIterator(new AbstractHashMap$EntrySetIterator, $AbstractHashMap$EntrySet(new AbstractHashMap$EntrySet, this$static).this$0); $hasNext_1(entry$iterator.iter);) {
    entry = dynamicCast($next_3(entry$iterator.iter), 78);
    hashCode += entry.hashCode$();
    hashCode = ~~hashCode;
  }
  return hashCode;
}

function $keySet(this$static){
  var entrySet;
  entrySet = $AbstractHashMap$EntrySet(new AbstractHashMap$EntrySet, this$static);
  return $AbstractMap$1(new AbstractMap$1, this$static, entrySet);
}

function $toString_3(this$static){
  var comma, entry, iter, s;
  s = '{';
  comma = false;
  for (iter = $AbstractHashMap$EntrySetIterator(new AbstractHashMap$EntrySetIterator, $AbstractHashMap$EntrySet(new AbstractHashMap$EntrySet, this$static).this$0); $hasNext_1(iter.iter);) {
    entry = dynamicCast($next_3(iter.iter), 78);
    comma?(s += ', '):(comma = true);
    s += '' + entry.getKey();
    s += '=';
    s += '' + entry.getValue();
  }
  return s + '}';
}

function equals_9(obj){
  return $equals_4(this, obj);
}

function getClass_200(){
  return Ljava_util_AbstractMap_2_classLit;
}

function hashCode_11(){
  return $hashCode_4(this);
}

function size_1(){
  return $AbstractHashMap$EntrySet(new AbstractHashMap$EntrySet, dynamicCast(this, 77)).this$0.size;
}

function toString_17(){
  return $toString_3(this);
}

function AbstractMap(){
}

_ = AbstractMap.prototype = new Object_0;
_.equals$ = equals_9;
_.getClass$ = getClass_200;
_.hashCode$ = hashCode_11;
_.size_0 = size_1;
_.toString$ = toString_17;
_.typeId$ = 105;
function $addAllHashEntries(this$static, dest){
  var hashCodeMap = this$static.hashCodeMap;
  for (var hashCode in hashCodeMap) {
    if (hashCode == parseInt(hashCode)) {
      var array = hashCodeMap[hashCode];
      for (var i = 0, c = array.length; i < c; ++i) {
        dest.add(array[i]);
      }
    }
  }
}

function $addAllStringEntries(this$static, dest){
  var stringMap = this$static.stringMap;
  for (var key in stringMap) {
    if (key.charCodeAt(0) == 58) {
      var entry = new_$(this$static, key.substring(1));
      dest.add(entry);
    }
  }
}

function $clearImpl(this$static){
  this$static.hashCodeMap = [];
  this$static.stringMap = {};
  this$static.nullSlotLive = false;
  this$static.nullSlot = null;
  this$static.size = 0;
}

function $containsKey(this$static, key){
  return key == null?this$static.nullSlotLive:key != null && canCast(key.typeId$, 1)?$hasStringValue(this$static, dynamicCast(key, 1)):$hasHashValue(this$static, key, ~~hashCode__devirtual$(key));
}

function $get_5(this$static, key){
  return key == null?this$static.nullSlot:key != null && canCast(key.typeId$, 1)?this$static.stringMap[':' + dynamicCast(key, 1)]:$getHashValue(this$static, key, ~~hashCode__devirtual$(key));
}

function $getHashValue(this$static, key, hashCode){
  var array = this$static.hashCodeMap[hashCode];
  if (array) {
    for (var i = 0, c = array.length; i < c; ++i) {
      var entry = array[i];
      var entryKey = entry.getKey();
      if (this$static.equalsBridge(key, entryKey)) {
        return entry.getValue();
      }
    }
  }
  return null;
}

function $hasHashValue(this$static, key, hashCode){
  var array = this$static.hashCodeMap[hashCode];
  if (array) {
    for (var i = 0, c = array.length; i < c; ++i) {
      var entry = array[i];
      var entryKey = entry.getKey();
      if (this$static.equalsBridge(key, entryKey)) {
        return true;
      }
    }
  }
  return false;
}

function $hasStringValue(this$static, key){
  return ':' + key in this$static.stringMap;
}

function $put(this$static, key, value){
  return key == null?$putNullSlot(this$static, value):key != null && canCast(key.typeId$, 1)?$putStringValue(this$static, dynamicCast(key, 1), value):$putHashValue(this$static, key, value, ~~hashCode__devirtual$(key));
}

function $putHashValue(this$static, key, value, hashCode){
  var array = this$static.hashCodeMap[hashCode];
  if (array) {
    for (var i = 0, c = array.length; i < c; ++i) {
      var entry = array[i];
      var entryKey = entry.getKey();
      if (this$static.equalsBridge(key, entryKey)) {
        var previous = entry.getValue();
        entry.setValue(value);
        return previous;
      }
    }
  }
   else {
    array = this$static.hashCodeMap[hashCode] = [];
  }
  var entry = $MapEntryImpl(new MapEntryImpl, key, value);
  array.push(entry);
  ++this$static.size;
  return null;
}

function $putNullSlot(this$static, value){
  var result;
  result = this$static.nullSlot;
  this$static.nullSlot = value;
  if (!this$static.nullSlotLive) {
    this$static.nullSlotLive = true;
    ++this$static.size;
  }
  return result;
}

function $putStringValue(this$static, key, value){
  var result, stringMap = this$static.stringMap;
  key = ':' + key;
  key in stringMap?(result = stringMap[key]):++this$static.size;
  stringMap[key] = value;
  return result;
}

function $remove_5(this$static, key){
  return !key?$removeNullSlot(this$static):$removeHashValue(this$static, key, ~~(key.$H || (key.$H = ++sNextHashId)));
}

function $removeHashValue(this$static, key, hashCode){
  var array = this$static.hashCodeMap[hashCode];
  if (array) {
    for (var i = 0, c = array.length; i < c; ++i) {
      var entry = array[i];
      var entryKey = entry.getKey();
      if (this$static.equalsBridge(key, entryKey)) {
        array.length == 1?delete this$static.hashCodeMap[hashCode]:array.splice(i, 1);
        --this$static.size;
        return entry.getValue();
      }
    }
  }
  return null;
}

function $removeNullSlot(this$static){
  var result;
  result = this$static.nullSlot;
  this$static.nullSlot = null;
  if (this$static.nullSlotLive) {
    this$static.nullSlotLive = false;
    --this$static.size;
  }
  return result;
}

function entrySet_0(){
  return $AbstractHashMap$EntrySet(new AbstractHashMap$EntrySet, dynamicCast(this, 77));
}

function equalsBridge(value1, value2){
  return (value1 == null?null:value1) === (value2 == null?null:value2) || value1 != null && equals__devirtual$(value1, value2);
}

function getClass_201(){
  return Ljava_util_AbstractHashMap_2_classLit;
}

function size_2(){
  return dynamicCast(this, 77).size;
}

function AbstractHashMap(){
}

_ = AbstractHashMap.prototype = new AbstractMap;
_.entrySet_0 = entrySet_0;
_.equalsBridge = equalsBridge;
_.getClass$ = getClass_201;
_.size_0 = size_2;
_.typeId$ = 106;
_.hashCodeMap = null;
_.nullSlot = null;
_.nullSlotLive = false;
_.size = 0;
_.stringMap = null;
function equals_10(o){
  var iter, other, otherItem;
  if ((o == null?null:o) === this) {
    return true;
  }
  if (!(o != null && canCast(o.typeId$, 81))) {
    return false;
  }
  other = dynamicCast(o, 81);
  if (other.size_0() != this.size_0()) {
    return false;
  }
  for (iter = other.iterator_0(); iter.hasNext();) {
    otherItem = iter.next_0();
    if (!this.contains(otherItem)) {
      return false;
    }
  }
  return true;
}

function getClass_202(){
  return Ljava_util_AbstractSet_2_classLit;
}

function hashCode_12(){
  var hashCode, iter, next;
  hashCode = 0;
  for (iter = this.iterator_0(); iter.hasNext();) {
    next = iter.next_0();
    if (next != null) {
      hashCode += hashCode__devirtual$(next);
      hashCode = ~~hashCode;
    }
  }
  return hashCode;
}

function AbstractSet(){
}

_ = AbstractSet.prototype = new AbstractCollection;
_.equals$ = equals_10;
_.getClass$ = getClass_202;
_.hashCode$ = hashCode_12;
_.typeId$ = 107;
function $AbstractHashMap$EntrySet(this$static, this$0){
  this$static.this$0 = this$0;
  return this$static;
}

function $contains(this$static, o){
  var entry, key, value;
  if (o != null && canCast(o.typeId$, 78)) {
    entry = dynamicCast(o, 78);
    key = entry.getKey();
    if ($containsKey(this$static.this$0, key)) {
      value = $get_5(this$static.this$0, key);
      return $equals_5(entry.getValue(), value);
    }
  }
  return false;
}

function contains_0(o){
  return $contains(this, o);
}

function getClass_203(){
  return Ljava_util_AbstractHashMap$EntrySet_2_classLit;
}

function iterator_3(){
  return $AbstractHashMap$EntrySetIterator(new AbstractHashMap$EntrySetIterator, this.this$0);
}

function size_3(){
  return this.this$0.size;
}

function AbstractHashMap$EntrySet(){
}

_ = AbstractHashMap$EntrySet.prototype = new AbstractSet;
_.contains = contains_0;
_.getClass$ = getClass_203;
_.iterator_0 = iterator_3;
_.size_0 = size_3;
_.typeId$ = 108;
_.this$0 = null;
function $AbstractHashMap$EntrySetIterator(this$static, this$0){
  var list;
  this$static.this$0 = this$0;
  list = $ArrayList(new ArrayList);
  this$static.this$0.nullSlotLive && $add_7(list, $AbstractHashMap$MapEntryNull(new AbstractHashMap$MapEntryNull, this$static.this$0));
  $addAllStringEntries(this$static.this$0, list);
  $addAllHashEntries(this$static.this$0, list);
  this$static.iter = $AbstractList$IteratorImpl(new AbstractList$IteratorImpl, list);
  return this$static;
}

function getClass_204(){
  return Ljava_util_AbstractHashMap$EntrySetIterator_2_classLit;
}

function hasNext_2(){
  return $hasNext_1(this.iter);
}

function next_3(){
  return dynamicCast($next_3(this.iter), 78);
}

function AbstractHashMap$EntrySetIterator(){
}

_ = AbstractHashMap$EntrySetIterator.prototype = new Object_0;
_.getClass$ = getClass_204;
_.hasNext = hasNext_2;
_.next_0 = next_3;
_.typeId$ = 0;
_.iter = null;
_.this$0 = null;
function equals_11(other){
  var entry;
  if (other != null && canCast(other.typeId$, 78)) {
    entry = dynamicCast(other, 78);
    if (equalsWithNullCheck(this.getKey(), entry.getKey()) && equalsWithNullCheck(this.getValue(), entry.getValue())) {
      return true;
    }
  }
  return false;
}

function getClass_205(){
  return Ljava_util_AbstractMapEntry_2_classLit;
}

function hashCode_13(){
  var keyHash, valueHash;
  keyHash = 0;
  valueHash = 0;
  this.getKey() != null && (keyHash = hashCode__devirtual$(this.getKey()));
  this.getValue() != null && (valueHash = hashCode__devirtual$(this.getValue()));
  return keyHash ^ valueHash;
}

function toString_18(){
  return this.getKey() + '=' + this.getValue();
}

function AbstractMapEntry(){
}

_ = AbstractMapEntry.prototype = new Object_0;
_.equals$ = equals_11;
_.getClass$ = getClass_205;
_.hashCode$ = hashCode_13;
_.toString$ = toString_18;
_.typeId$ = 109;
function $AbstractHashMap$MapEntryNull(this$static, this$0){
  this$static.this$0 = this$0;
  return this$static;
}

function getClass_206(){
  return Ljava_util_AbstractHashMap$MapEntryNull_2_classLit;
}

function getKey(){
  return null;
}

function getValue(){
  return this.this$0.nullSlot;
}

function setValue(object){
  return $putNullSlot(this.this$0, object);
}

--></script>
<script><!--
function AbstractHashMap$MapEntryNull(){
}

_ = AbstractHashMap$MapEntryNull.prototype = new AbstractMapEntry;
_.getClass$ = getClass_206;
_.getKey = getKey;
_.getValue = getValue;
_.setValue = setValue;
_.typeId$ = 110;
_.this$0 = null;
function $AbstractHashMap$MapEntryString(this$static, key, this$0){
  this$static.this$0 = this$0;
  this$static.key = key;
  return this$static;
}

function getClass_207(){
  return Ljava_util_AbstractHashMap$MapEntryString_2_classLit;
}

function getKey_0(){
  return this.key;
}

function getValue_0(){
  return this.this$0.stringMap[':' + this.key];
}

function new_$(this$outer, key){
  return $AbstractHashMap$MapEntryString(new AbstractHashMap$MapEntryString, key, this$outer);
}

function setValue_0(object){
  return $putStringValue(this.this$0, this.key, object);
}

function AbstractHashMap$MapEntryString(){
}

_ = AbstractHashMap$MapEntryString.prototype = new AbstractMapEntry;
_.getClass$ = getClass_207;
_.getKey = getKey_0;
_.getValue = getValue_0;
_.setValue = setValue_0;
_.typeId$ = 111;
_.key = null;
_.this$0 = null;
function $AbstractList$IteratorImpl(this$static, this$0){
  this$static.this$0 = this$0;
  return this$static;
}

function $hasNext_1(this$static){
  return this$static.i < this$static.this$0.size_0();
}

function $next_3(this$static){
  if (this$static.i >= this$static.this$0.size_0()) {
    throw $NoSuchElementException(new NoSuchElementException);
  }
  return this$static.this$0.get(this$static.i++);
}

function getClass_208(){
  return Ljava_util_AbstractList$IteratorImpl_2_classLit;
}

function hasNext_3(){
  return this.i < this.this$0.size_0();
}

function next_4(){
  return $next_3(this);
}

function AbstractList$IteratorImpl(){
}

_ = AbstractList$IteratorImpl.prototype = new Object_0;
_.getClass$ = getClass_208;
_.hasNext = hasNext_3;
_.next_0 = next_4;
_.typeId$ = 0;
_.i = 0;
_.this$0 = null;
function $AbstractMap$1(this$static, this$0, val$entrySet){
  this$static.this$0 = this$0;
  this$static.val$entrySet = val$entrySet;
  return this$static;
}

function contains_1(key){
  return $containsKey(this.this$0, key);
}

function getClass_209(){
  return Ljava_util_AbstractMap$1_2_classLit;
}

function iterator_4(){
  var outerIter;
  return outerIter = $AbstractHashMap$EntrySetIterator(new AbstractHashMap$EntrySetIterator, this.val$entrySet.this$0) , $AbstractMap$1$1(new AbstractMap$1$1, outerIter);
}

function size_4(){
  return this.val$entrySet.this$0.size;
}

function AbstractMap$1(){
}

_ = AbstractMap$1.prototype = new AbstractSet;
_.contains = contains_1;
_.getClass$ = getClass_209;
_.iterator_0 = iterator_4;
_.size_0 = size_4;
_.typeId$ = 112;
_.this$0 = null;
_.val$entrySet = null;
function $AbstractMap$1$1(this$static, val$outerIter){
  this$static.val$outerIter = val$outerIter;
  return this$static;
}

function getClass_210(){
  return Ljava_util_AbstractMap$1$1_2_classLit;
}

function hasNext_4(){
  return $hasNext_1(this.val$outerIter.iter);
}

function next_5(){
  var entry;
  return entry = dynamicCast($next_3(this.val$outerIter.iter), 78) , entry.getKey();
}

function AbstractMap$1$1(){
}

_ = AbstractMap$1$1.prototype = new Object_0;
_.getClass$ = getClass_210;
_.hasNext = hasNext_4;
_.next_0 = next_5;
_.typeId$ = 0;
_.val$outerIter = null;
function $ArrayList(this$static){
  this$static.array = initDim(_3Ljava_lang_Object_2_classLit, 157, 0, 0, 0);
  return this$static;
}

function $add_7(this$static, o){
  setCheck(this$static.array, this$static.size++, o);
  return true;
}

function $add_8(this$static, index, o){
  (index < 0 || index > this$static.size) && indexOutOfBounds(index, this$static.size);
  this$static.array.splice(index, 0, o);
  ++this$static.size;
}

function $clear(this$static){
  this$static.array = initDim(_3Ljava_lang_Object_2_classLit, 157, 0, 0, 0);
  this$static.size = 0;
}

function $get_6(this$static, index){
  checkIndex(index, this$static.size);
  return this$static.array[index];
}

function $indexOf_2(this$static, o, index){
  for (; index < this$static.size; ++index) {
    if (equalsWithNullCheck(o, this$static.array[index])) {
      return index;
    }
  }
  return -1;
}

function $remove_6(this$static, index){
  var previous;
  previous = (checkIndex(index, this$static.size) , this$static.array[index]);
  this$static.array.splice(index, 1);
  --this$static.size;
  return previous;
}

function $remove_7(this$static, o){
  var i;
  i = $indexOf_2(this$static, o, 0);
  if (i == -1) {
    return false;
  }
  $remove_6(this$static, i);
  return true;
}

function $set_12(this$static, index, o){
  var previous;
  previous = (checkIndex(index, this$static.size) , this$static.array[index]);
  setCheck(this$static.array, index, o);
  return previous;
}

function add_6(o){
  return setCheck(this.array, this.size++, o) , true;
}

function add_7(index, o){
  $add_8(this, index, o);
}

function contains_2(o){
  return $indexOf_2(this, o, 0) != -1;
}

function get_4(index){
  return checkIndex(index, this.size) , this.array[index];
}

function getClass_211(){
  return Ljava_util_ArrayList_2_classLit;
}

function set_2(index, o){
  var previous;
  return previous = (checkIndex(index, this.size) , this.array[index]) , setCheck(this.array, index, o) , previous;
}

function size_5(){
  return this.size;
}

function ArrayList(){
}

_ = ArrayList.prototype = new AbstractList;
_.add = add_6;
_.add_0 = add_7;
_.contains = contains_2;
_.get = get_4;
_.getClass$ = getClass_211;
_.set = set_2;
_.size_0 = size_5;
_.typeId$ = 113;
_.size = 0;
function fill(a, fromIndex, toIndex, val){
  var i;
  for (i = fromIndex; i < toIndex; ++i) {
    setCheck(a, i, val);
  }
}

function fill_0(a, val){
  fill(a, 0, a.length, val);
}

function $clinit_313(){
  $clinit_313 = nullMethod;
  unmodifiableList($ArrayList(new ArrayList));
  $Collections$UnmodifiableMap(new Collections$UnmodifiableMap, $HashMap(new HashMap));
  $Collections$UnmodifiableCollection(new Collections$UnmodifiableSet, $HashSet(new HashSet));
}

function binarySearch(sortedList, key, comparator){
  $clinit_313();
  var compareResult, high, low, mid, midVal;
  !comparator && (comparator = ($clinit_324() , $clinit_324() , NATURAL));
  low = 0;
  high = sortedList.size - 1;
  while (low <= high) {
    mid = low + (high - low >> 1);
    midVal = (checkIndex(mid, sortedList.size) , sortedList.array[mid]);
    compareResult = comparator.compare(midVal, key);
    if (compareResult < 0) {
      low = mid + 1;
    }
     else if (compareResult > 0) {
      high = mid - 1;
    }
     else {
      return mid;
    }
  }
  return -low - 1;
}

function swapImpl(list, i, j){
  var previous;
  $clinit_313();
  var t;
  t = (checkIndex(i, list.size) , list.array[i]);
  $set_12(list, i, (checkIndex(j, list.size) , list.array[j]));
  previous = (checkIndex(j, list.size) , list.array[j]);
  setCheck(list.array, j, t);
}

function unmodifiableList(list){
  return list?$Collections$UnmodifiableRandomAccessList(new Collections$UnmodifiableRandomAccessList, list):$Collections$UnmodifiableList(new Collections$UnmodifiableList, list);
}

function $Collections$UnmodifiableCollection(this$static, coll){
  this$static.coll = coll;
  return this$static;
}

function add_8(o){
  throw $UnsupportedOperationException(new UnsupportedOperationException);
}

function getClass_212(){
  return Ljava_util_Collections$UnmodifiableCollection_2_classLit;
}

function iterator_5(){
  return $Collections$UnmodifiableCollectionIterator(new Collections$UnmodifiableCollectionIterator, this.coll.iterator_0());
}

function size_6(){
  return this.coll.size_0();
}

function toString_19(){
  return this.coll.toString$();
}

function Collections$UnmodifiableCollection(){
}

_ = Collections$UnmodifiableCollection.prototype = new Object_0;
_.add = add_8;
_.getClass$ = getClass_212;
_.iterator_0 = iterator_5;
_.size_0 = size_6;
_.toString$ = toString_19;
_.typeId$ = 0;
_.coll = null;
function $Collections$UnmodifiableCollectionIterator(this$static, it){
  this$static.it = it;
  return this$static;
}

function getClass_213(){
  return Ljava_util_Collections$UnmodifiableCollectionIterator_2_classLit;
}

function hasNext_5(){
  return this.it.hasNext();
}

function next_6(){
  return this.it.next_0();
}

function Collections$UnmodifiableCollectionIterator(){
}

_ = Collections$UnmodifiableCollectionIterator.prototype = new Object_0;
_.getClass$ = getClass_213;
_.hasNext = hasNext_5;
_.next_0 = next_6;
_.typeId$ = 0;
_.it = null;
function $Collections$UnmodifiableList(this$static, list){
  this$static.coll = list;
  this$static.list = list;
  return this$static;
}

function equals_12(o){
  return $equals_0(this.list, o);
}

function get_5(index){
  return $get_6(this.list, index);
}

function getClass_214(){
  return Ljava_util_Collections$UnmodifiableList_2_classLit;
}

function hashCode_14(){
  return $hashCode_0(this.list);
}

function set_3(index, element){
  throw $UnsupportedOperationException(new UnsupportedOperationException);
}

function Collections$UnmodifiableList(){
}

_ = Collections$UnmodifiableList.prototype = new Collections$UnmodifiableCollection;
_.equals$ = equals_12;
_.get = get_5;
_.getClass$ = getClass_214;
_.hashCode$ = hashCode_14;
_.set = set_3;
_.typeId$ = 114;
_.list = null;
function $Collections$UnmodifiableMap(this$static, map){
  this$static.map = map;
  return this$static;
}

function entrySet_1(){
  !this.entrySet && (this.entrySet = $Collections$UnmodifiableMap$UnmodifiableEntrySet(new Collections$UnmodifiableMap$UnmodifiableEntrySet, $AbstractHashMap$EntrySet(new AbstractHashMap$EntrySet, this.map)));
  return this.entrySet;
}

function equals_13(o){
  return $equals_4(this.map, o);
}

function getClass_215(){
  return Ljava_util_Collections$UnmodifiableMap_2_classLit;
}

function hashCode_15(){
  return $hashCode_4(this.map);
}

function size_7(){
  return this.map.size;
}

function toString_20(){
  return $toString_3(this.map);
}

function Collections$UnmodifiableMap(){
}

_ = Collections$UnmodifiableMap.prototype = new Object_0;
_.entrySet_0 = entrySet_1;
_.equals$ = equals_13;
_.getClass$ = getClass_215;
_.hashCode$ = hashCode_15;
_.size_0 = size_7;
_.toString$ = toString_20;
_.typeId$ = 115;
_.entrySet = null;
_.map = null;
function equals_14(o){
  return this.coll.equals$(o);
}

function getClass_216(){
  return Ljava_util_Collections$UnmodifiableSet_2_classLit;
}

function hashCode_16(){
  return this.coll.hashCode$();
}

function Collections$UnmodifiableSet(){
}

_ = Collections$UnmodifiableSet.prototype = new Collections$UnmodifiableCollection;
_.equals$ = equals_14;
_.getClass$ = getClass_216;
_.hashCode$ = hashCode_16;
_.typeId$ = 116;
function $Collections$UnmodifiableMap$UnmodifiableEntrySet(this$static, s){
  this$static.coll = s;
  return this$static;
}

function getClass_217(){
  return Ljava_util_Collections$UnmodifiableMap$UnmodifiableEntrySet_2_classLit;
}

function iterator_6(){
  var it;
  it = this.coll.iterator_0();
  return $Collections$UnmodifiableMap$UnmodifiableEntrySet$1(new Collections$UnmodifiableMap$UnmodifiableEntrySet$1, it);
}

function Collections$UnmodifiableMap$UnmodifiableEntrySet(){
}

_ = Collections$UnmodifiableMap$UnmodifiableEntrySet.prototype = new Collections$UnmodifiableSet;
_.getClass$ = getClass_217;
_.iterator_0 = iterator_6;
_.typeId$ = 117;
function $Collections$UnmodifiableMap$UnmodifiableEntrySet$1(this$static, val$it){
  this$static.val$it = val$it;
  return this$static;
}

function getClass_218(){
  return Ljava_util_Collections$UnmodifiableMap$UnmodifiableEntrySet$1_2_classLit;
}

function hasNext_6(){
  return this.val$it.hasNext();
}

function next_7(){
  return $Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntry(new Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntry, dynamicCast(this.val$it.next_0(), 78));
}

function Collections$UnmodifiableMap$UnmodifiableEntrySet$1(){
}

_ = Collections$UnmodifiableMap$UnmodifiableEntrySet$1.prototype = new Object_0;
_.getClass$ = getClass_218;
_.hasNext = hasNext_6;
_.next_0 = next_7;
_.typeId$ = 0;
_.val$it = null;
function $Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntry(this$static, entry){
  this$static.entry = entry;
  return this$static;
}

function equals_15(o){
  return this.entry.equals$(o);
}

function getClass_219(){
  return Ljava_util_Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntry_2_classLit;
}

function getKey_1(){
  return this.entry.getKey();
}

function getValue_1(){
  return this.entry.getValue();
}

function hashCode_17(){
  return this.entry.hashCode$();
}

function setValue_1(value){
  throw $UnsupportedOperationException(new UnsupportedOperationException);
}

function toString_21(){
  return toString__devirtual$(this.entry);
}

function Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntry(){
}

_ = Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntry.prototype = new Object_0;
_.equals$ = equals_15;
_.getClass$ = getClass_219;
_.getKey = getKey_1;
_.getValue = getValue_1;
_.hashCode$ = hashCode_17;
_.setValue = setValue_1;
_.toString$ = toString_21;
_.typeId$ = 118;
_.entry = null;
function $Collections$UnmodifiableRandomAccessList(this$static, list){
  this$static.coll = list;
  this$static.list = list;
  return this$static;
}

function getClass_220(){
  return Ljava_util_Collections$UnmodifiableRandomAccessList_2_classLit;
}

function Collections$UnmodifiableRandomAccessList(){
}

_ = Collections$UnmodifiableRandomAccessList.prototype = new Collections$UnmodifiableList;
_.getClass$ = getClass_220;
_.typeId$ = 119;
function $clinit_324(){
  $clinit_324 = nullMethod;
  NATURAL = new Comparators$1;
}

var NATURAL;
function compare_7(o1, o2){
  return dynamicCast(o1, 41).compareTo$(o2);
}

function getClass_221(){
  return Ljava_util_Comparators$1_2_classLit;
}

function Comparators$1(){
}

_ = Comparators$1.prototype = new Object_0;
_.compare = compare_7;
_.getClass$ = getClass_221;
_.typeId$ = 0;
function $HashMap(this$static){
  $clearImpl(this$static);
  return this$static;
}

function $equals_5(value1, value2){
  return (value1 == null?null:value1) === (value2 == null?null:value2) || value1 != null && equals__devirtual$(value1, value2);
}

function getClass_222(){
  return Ljava_util_HashMap_2_classLit;
}

function HashMap(){
}

_ = HashMap.prototype = new AbstractHashMap;
_.getClass$ = getClass_222;
_.typeId$ = 120;
function $HashSet(this$static){
  this$static.map = $HashMap(new HashMap);
  return this$static;
}

function $add_9(this$static, o){
  var old;
  old = $put(this$static.map, o, this$static);
  return old == null;
}

function add_9(o){
  var old;
  return old = $put(this.map, o, this) , old == null;
}

function contains_3(o){
  return $containsKey(this.map, o);
}

function getClass_223(){
  return Ljava_util_HashSet_2_classLit;
}

function iterator_7(){
  var outerIter;
  return outerIter = $AbstractHashMap$EntrySetIterator(new AbstractHashMap$EntrySetIterator, $keySet(this.map).val$entrySet.this$0) , $AbstractMap$1$1(new AbstractMap$1$1, outerIter);
}

function size_8(){
  return this.map.size;
}

function toString_22(){
  return $toString($keySet(this.map));
}

function HashSet(){
}

_ = HashSet.prototype = new AbstractSet;
_.add = add_9;
_.contains = contains_3;
_.getClass$ = getClass_223;
_.iterator_0 = iterator_7;
_.size_0 = size_8;
_.toString$ = toString_22;
_.typeId$ = 121;
_.map = null;
function $MapEntryImpl(this$static, key, value){
  this$static.key = key;
  this$static.value_0 = value;
  return this$static;
}

function getClass_224(){
  return Ljava_util_MapEntryImpl_2_classLit;
}

function getKey_2(){
  return this.key;
}

function getValue_2(){
  return this.value_0;
}

function setValue_2(value){
  var old;
  old = this.value_0;
  this.value_0 = value;
  return old;
}

function MapEntryImpl(){
}

_ = MapEntryImpl.prototype = new AbstractMapEntry;
_.getClass$ = getClass_224;
_.getKey = getKey_2;
_.getValue = getValue_2;
_.setValue = setValue_2;
_.typeId$ = 122;
_.key = null;
_.value_0 = null;
function $NoSuchElementException(this$static){
  $fillInStackTrace();
  return this$static;
}

function getClass_225(){
  return Ljava_util_NoSuchElementException_2_classLit;
}

function NoSuchElementException(){
}

_ = NoSuchElementException.prototype = new RuntimeException;
_.getClass$ = getClass_225;
_.typeId$ = 123;
function equalsWithNullCheck(a, b){
  return (a == null?null:a) === (b == null?null:b) || a != null && equals__devirtual$(a, b);
}

var $entry = entry_0;
function gwtOnLoad(errFn, modName, modBase){
  $moduleName = modName;
  $moduleBase = modBase;
  if (errFn)
    try {
      $entry(init)();
    }
     catch (e) {
      errFn(modName);
    }
   else {
    $entry(init)();
  }
}

--></script>
<script><!--
var Ljava_lang_Object_2_classLit = createForClass('java.lang.', 'Object'), Lcom_bulletphysics_gwt_client_collision_broadphase_AxisSweep3Internal_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.broadphase.', 'AxisSweep3Internal'), Lcom_bulletphysics_gwt_client_collision_broadphase_AxisSweep3_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.broadphase.', 'AxisSweep3'), S_classLit = createForPrimitive('', 'short'), _3S_classLit = createForArray('', '[S', S_classLit), Lcom_bulletphysics_gwt_client_collision_broadphase_AxisSweep3Internal$EdgeArray_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.broadphase.', 'AxisSweep3Internal$EdgeArray'), Lcom_bulletphysics_gwt_client_collision_broadphase_AxisSweep3$EdgeArrayImpl_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.broadphase.', 'AxisSweep3$EdgeArrayImpl'), Lcom_bulletphysics_gwt_client_collision_broadphase_BroadphaseProxy_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.broadphase.', 'BroadphaseProxy'), Lcom_bulletphysics_gwt_client_collision_broadphase_AxisSweep3Internal$Handle_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.broadphase.', 'AxisSweep3Internal$Handle'), Lcom_bulletphysics_gwt_client_collision_broadphase_AxisSweep3$HandleImpl_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.broadphase.', 'AxisSweep3$HandleImpl'), _3Lcom_bulletphysics_gwt_client_collision_broadphase_AxisSweep3Internal$EdgeArray_2_classLit = createForArray('[Lcom.bulletphysics.gwt.client.collision.broadphase.', 'AxisSweep3Internal$EdgeArray;', Lcom_bulletphysics_gwt_client_collision_broadphase_AxisSweep3Internal$EdgeArray_2_classLit), _3Lcom_bulletphysics_gwt_client_collision_broadphase_AxisSweep3Internal$Handle_2_classLit = createForArray('[Lcom.bulletphysics.gwt.client.collision.broadphase.', 'AxisSweep3Internal$Handle;', Lcom_bulletphysics_gwt_client_collision_broadphase_AxisSweep3Internal$Handle_2_classLit), Lcom_bulletphysics_gwt_client_collision_broadphase_BroadphasePair_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.broadphase.', 'BroadphasePair'), I_classLit = createForPrimitive('', 'int'), _3I_classLit = createForArray('', '[I', I_classLit), Ljava_lang_Enum_2_classLit = createForClass('java.lang.', 'Enum'), Lcom_bulletphysics_gwt_client_collision_broadphase_BroadphaseNativeType_2_classLit = createForEnum('com.bulletphysics.gwt.client.collision.broadphase.', 'BroadphaseNativeType', values_1), _3Lcom_bulletphysics_gwt_client_collision_broadphase_BroadphaseNativeType_2_classLit = createForArray('[Lcom.bulletphysics.gwt.client.collision.broadphase.', 'BroadphaseNativeType;', Lcom_bulletphysics_gwt_client_collision_broadphase_BroadphaseNativeType_2_classLit), Lcom_bulletphysics_gwt_client_collision_broadphase_CollisionAlgorithm_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.broadphase.', 'CollisionAlgorithm'), Lcom_bulletphysics_gwt_client_collision_broadphase_CollisionAlgorithmConstructionInfo_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.broadphase.', 'CollisionAlgorithmConstructionInfo'), Lcom_bulletphysics_gwt_client_collision_broadphase_DispatchFunc_2_classLit = createForEnum('com.bulletphysics.gwt.client.collision.broadphase.', 'DispatchFunc', values_2), _3Lcom_bulletphysics_gwt_client_collision_broadphase_DispatchFunc_2_classLit = createForArray('[Lcom.bulletphysics.gwt.client.collision.broadphase.', 'DispatchFunc;', Lcom_bulletphysics_gwt_client_collision_broadphase_DispatchFunc_2_classLit), Lcom_bulletphysics_gwt_client_collision_broadphase_Dispatcher_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.broadphase.', 'Dispatcher'), Lcom_bulletphysics_gwt_client_collision_broadphase_DispatcherInfo_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.broadphase.', 'DispatcherInfo'), Lcom_bulletphysics_gwt_client_collision_broadphase_OverlappingPairCache_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.broadphase.', 'OverlappingPairCache'), Lcom_bulletphysics_gwt_client_collision_broadphase_HashedOverlappingPairCache_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.broadphase.', 'HashedOverlappingPairCache'), Lcom_bulletphysics_gwt_client_collision_dispatch_CollisionAlgorithmCreateFunc_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'CollisionAlgorithmCreateFunc'), Lcom_bulletphysics_gwt_client_collision_dispatch_CollisionConfiguration_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'CollisionConfiguration'), Lcom_bulletphysics_gwt_client_collision_narrowphase_PersistentManifold_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.narrowphase.', 'PersistentManifold'), _3Lcom_bulletphysics_gwt_client_collision_dispatch_CollisionAlgorithmCreateFunc_2_classLit = createForArray('[Lcom.bulletphysics.gwt.client.collision.dispatch.', 'CollisionAlgorithmCreateFunc;', Lcom_bulletphysics_gwt_client_collision_dispatch_CollisionAlgorithmCreateFunc_2_classLit), _3_3Lcom_bulletphysics_gwt_client_collision_dispatch_CollisionAlgorithmCreateFunc_2_classLit = createForArray('[[Lcom.bulletphysics.gwt.client.collision.dispatch.', 'CollisionAlgorithmCreateFunc;', _3Lcom_bulletphysics_gwt_client_collision_dispatch_CollisionAlgorithmCreateFunc_2_classLit), Lcom_bulletphysics_gwt_client_collision_dispatch_CollisionDispatcher_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'CollisionDispatcher'), Lcom_bulletphysics_gwt_client_collision_dispatch_CollisionDispatcher$CollisionPairCallback_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'CollisionDispatcher$CollisionPairCallback'), Lcom_bulletphysics_gwt_client_collision_dispatch_CollisionObject_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'CollisionObject'), Lcom_bulletphysics_gwt_client_collision_dispatch_CollisionObjectType_2_classLit = createForEnum('com.bulletphysics.gwt.client.collision.dispatch.', 'CollisionObjectType', values_3), _3Lcom_bulletphysics_gwt_client_collision_dispatch_CollisionObjectType_2_classLit = createForArray('[Lcom.bulletphysics.gwt.client.collision.dispatch.', 'CollisionObjectType;', Lcom_bulletphysics_gwt_client_collision_dispatch_CollisionObjectType_2_classLit), F_classLit = createForPrimitive('', 'float'), _3F_classLit = createForArray('', '[F', F_classLit), Lcom_bulletphysics_gwt_client_collision_dispatch_CollisionWorld_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'CollisionWorld'), Lcom_bulletphysics_gwt_client_collision_dispatch_CompoundCollisionAlgorithm_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'CompoundCollisionAlgorithm'), Lcom_bulletphysics_gwt_client_collision_dispatch_CompoundCollisionAlgorithm$CreateFunc_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'CompoundCollisionAlgorithm$CreateFunc'), Lcom_bulletphysics_gwt_client_collision_dispatch_CompoundCollisionAlgorithm$SwappedCreateFunc_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'CompoundCollisionAlgorithm$SwappedCreateFunc'), Lcom_bulletphysics_gwt_client_collision_dispatch_ConvexConcaveCollisionAlgorithm_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'ConvexConcaveCollisionAlgorithm'), Lcom_bulletphysics_gwt_client_collision_dispatch_ConvexConcaveCollisionAlgorithm$LocalTriangleSphereCastCallback_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'ConvexConcaveCollisionAlgorithm$LocalTriangleSphereCastCallback'), Lcom_bulletphysics_gwt_client_collision_dispatch_ConvexConcaveCollisionAlgorithm$CreateFunc_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'ConvexConcaveCollisionAlgorithm$CreateFunc'), Lcom_bulletphysics_gwt_client_collision_dispatch_ConvexConcaveCollisionAlgorithm$SwappedCreateFunc_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'ConvexConcaveCollisionAlgorithm$SwappedCreateFunc'), Lcom_bulletphysics_gwt_client_collision_narrowphase_DiscreteCollisionDetectorInterface$ClosestPointInput_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.narrowphase.', 'DiscreteCollisionDetectorInterface$ClosestPointInput'), Lcom_bulletphysics_gwt_client_collision_dispatch_ConvexConvexAlgorithm_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'ConvexConvexAlgorithm'), Lcom_bulletphysics_gwt_client_collision_dispatch_ConvexConvexAlgorithm$CreateFunc_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'ConvexConvexAlgorithm$CreateFunc'), Lcom_bulletphysics_gwt_client_collision_dispatch_ConvexPlaneCollisionAlgorithm_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'ConvexPlaneCollisionAlgorithm'), Lcom_bulletphysics_gwt_client_collision_dispatch_ConvexPlaneCollisionAlgorithm$CreateFunc_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'ConvexPlaneCollisionAlgorithm$CreateFunc'), Lcom_bulletphysics_gwt_client_collision_dispatch_ConvexTriangleCallback_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'ConvexTriangleCallback'), Lcom_bulletphysics_gwt_client_collision_dispatch_DefaultCollisionConfiguration_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'DefaultCollisionConfiguration'), Lcom_bulletphysics_gwt_client_collision_dispatch_DefaultNearCallback_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'DefaultNearCallback'), Lcom_bulletphysics_gwt_client_collision_dispatch_EmptyAlgorithm_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'EmptyAlgorithm'), Lcom_bulletphysics_gwt_client_collision_dispatch_EmptyAlgorithm$CreateFunc_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'EmptyAlgorithm$CreateFunc'), Lcom_bulletphysics_gwt_client_collision_narrowphase_ManifoldPoint_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.narrowphase.', 'ManifoldPoint'), Lcom_bulletphysics_gwt_client_collision_dispatch_ManifoldResult_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'ManifoldResult'), Lcom_bulletphysics_gwt_client_collision_dispatch_SimulationIslandManager_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'SimulationIslandManager'), Lcom_bulletphysics_gwt_client_collision_dispatch_SimulationIslandManager$1_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'SimulationIslandManager$1'), Lcom_bulletphysics_gwt_client_collision_dispatch_SphereSphereCollisionAlgorithm_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'SphereSphereCollisionAlgorithm'), Lcom_bulletphysics_gwt_client_collision_dispatch_SphereSphereCollisionAlgorithm$CreateFunc_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'SphereSphereCollisionAlgorithm$CreateFunc'), Lcom_bulletphysics_gwt_client_collision_dispatch_UnionFind$Element_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'UnionFind$Element'), Lcom_bulletphysics_gwt_client_collision_dispatch_UnionFind_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'UnionFind'), Lcom_bulletphysics_gwt_client_collision_dispatch_UnionFind$1_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.dispatch.', 'UnionFind$1'), Lcom_bulletphysics_gwt_client_collision_narrowphase_ConvexCast$CastResult_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.narrowphase.', 'ConvexCast$CastResult'), Lcom_bulletphysics_gwt_client_collision_narrowphase_DiscreteCollisionDetectorInterface_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.narrowphase.', 'DiscreteCollisionDetectorInterface'), Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkConvexCast_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.narrowphase.', 'GjkConvexCast'), Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaPenetrationDepthSolver_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.narrowphase.', 'GjkEpaPenetrationDepthSolver'), Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$Mkv_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.narrowphase.', 'GjkEpaSolver$Mkv'), Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$He_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.narrowphase.', 'GjkEpaSolver$He'), Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$Face_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.narrowphase.', 'GjkEpaSolver$Face'), _3_3I_classLit = createForArray('', '[[I', _3I_classLit), Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.narrowphase.', 'GjkEpaSolver'), Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$ResultsStatus_2_classLit = createForEnum('com.bulletphysics.gwt.client.collision.narrowphase.', 'GjkEpaSolver$ResultsStatus', values_4), _3Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$ResultsStatus_2_classLit = createForArray('[Lcom.bulletphysics.gwt.client.collision.narrowphase.', 'GjkEpaSolver$ResultsStatus;', Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$ResultsStatus_2_classLit), Lcom_bulletphysics_gwt_client_vecmath_Vector3f_2_classLit = createForClass('com.bulletphysics.gwt.client.vecmath.', 'Vector3f'), _3Lcom_bulletphysics_gwt_client_vecmath_Vector3f_2_classLit = createForArray('[Lcom.bulletphysics.gwt.client.vecmath.', 'Vector3f;', Lcom_bulletphysics_gwt_client_vecmath_Vector3f_2_classLit), Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$Results_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.narrowphase.', 'GjkEpaSolver$Results'), _3Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$He_2_classLit = createForArray('[Lcom.bulletphysics.gwt.client.collision.narrowphase.', 'GjkEpaSolver$He;', Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$He_2_classLit), Lcom_bulletphysics_gwt_client_vecmath_Matrix3f_2_classLit = createForClass('com.bulletphysics.gwt.client.vecmath.', 'Matrix3f'), _3Lcom_bulletphysics_gwt_client_vecmath_Matrix3f_2_classLit = createForArray('[Lcom.bulletphysics.gwt.client.vecmath.', 'Matrix3f;', Lcom_bulletphysics_gwt_client_vecmath_Matrix3f_2_classLit), Lcom_bulletphysics_gwt_client_collision_shapes_CollisionShape_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.shapes.', 'CollisionShape'), Lcom_bulletphysics_gwt_client_collision_shapes_ConvexShape_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.shapes.', 'ConvexShape'), _3Lcom_bulletphysics_gwt_client_collision_shapes_ConvexShape_2_classLit = createForArray('[Lcom.bulletphysics.gwt.client.collision.shapes.', 'ConvexShape;', Lcom_bulletphysics_gwt_client_collision_shapes_ConvexShape_2_classLit), _3Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$Mkv_2_classLit = createForArray('[Lcom.bulletphysics.gwt.client.collision.narrowphase.', 'GjkEpaSolver$Mkv;', Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$Mkv_2_classLit), Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$GJK_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.narrowphase.', 'GjkEpaSolver$GJK'), _3Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$Face_2_classLit = createForArray('[Lcom.bulletphysics.gwt.client.collision.narrowphase.', 'GjkEpaSolver$Face;', Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$Face_2_classLit), _3_3Lcom_bulletphysics_gwt_client_vecmath_Vector3f_2_classLit = createForArray('[[Lcom.bulletphysics.gwt.client.vecmath.', 'Vector3f;', _3Lcom_bulletphysics_gwt_client_vecmath_Vector3f_2_classLit), Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkEpaSolver$EPA_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.narrowphase.', 'GjkEpaSolver$EPA'), Lcom_bulletphysics_gwt_client_collision_narrowphase_GjkPairDetector_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.narrowphase.', 'GjkPairDetector'), _3Lcom_bulletphysics_gwt_client_collision_narrowphase_ManifoldPoint_2_classLit = createForArray('[Lcom.bulletphysics.gwt.client.collision.narrowphase.', 'ManifoldPoint;', Lcom_bulletphysics_gwt_client_collision_narrowphase_ManifoldPoint_2_classLit), Lcom_bulletphysics_gwt_client_collision_narrowphase_PointCollector_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.narrowphase.', 'PointCollector'), Lcom_bulletphysics_gwt_client_collision_narrowphase_VoronoiSimplexSolver$SubSimplexClosestResult_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.narrowphase.', 'VoronoiSimplexSolver$SubSimplexClosestResult'), Lcom_bulletphysics_gwt_client_collision_narrowphase_VoronoiSimplexSolver_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.narrowphase.', 'VoronoiSimplexSolver'), Lcom_bulletphysics_gwt_client_collision_narrowphase_VoronoiSimplexSolver$UsageBitfield_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.narrowphase.', 'VoronoiSimplexSolver$UsageBitfield'), Lcom_bulletphysics_gwt_client_collision_shapes_ConvexInternalShape_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.shapes.', 'ConvexInternalShape'), Lcom_bulletphysics_gwt_client_collision_shapes_PolyhedralConvexShape_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.shapes.', 'PolyhedralConvexShape'), Lcom_bulletphysics_gwt_client_collision_shapes_BoxShape_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.shapes.', 'BoxShape'), Lcom_bulletphysics_gwt_client_collision_shapes_SphereShape_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.shapes.', 'SphereShape'), Lcom_bulletphysics_gwt_client_collision_shapes_TriangleShape_2_classLit = createForClass('com.bulletphysics.gwt.client.collision.shapes.', 'TriangleShape'), Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_ConstraintSolver_2_classLit = createForClass('com.bulletphysics.gwt.client.dynamics.constraintsolver.', 'ConstraintSolver'), Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_JacobianEntry_2_classLit = createForClass('com.bulletphysics.gwt.client.dynamics.constraintsolver.', 'JacobianEntry'), Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_ContactConstraint$1_2_classLit = createForClass('com.bulletphysics.gwt.client.dynamics.constraintsolver.', 'ContactConstraint$1'), Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_ContactConstraint$2_2_classLit = createForClass('com.bulletphysics.gwt.client.dynamics.constraintsolver.', 'ContactConstraint$2'), Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_ContactConstraintEnum_2_classLit = createForEnum('com.bulletphysics.gwt.client.dynamics.constraintsolver.', 'ContactConstraintEnum', values_5), _3Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_ContactConstraintEnum_2_classLit = createForArray('[Lcom.bulletphysics.gwt.client.dynamics.constraintsolver.', 'ContactConstraintEnum;', Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_ContactConstraintEnum_2_classLit), Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_ContactSolverInfo_2_classLit = createForClass('com.bulletphysics.gwt.client.dynamics.constraintsolver.', 'ContactSolverInfo'), Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_SequentialImpulseConstraintSolver$OrderIndex_2_classLit = createForClass('com.bulletphysics.gwt.client.dynamics.constraintsolver.', 'SequentialImpulseConstraintSolver$OrderIndex'), _3Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_SequentialImpulseConstraintSolver$OrderIndex_2_classLit = createForArray('[Lcom.bulletphysics.gwt.client.dynamics.constraintsolver.', 'SequentialImpulseConstraintSolver$OrderIndex;', Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_SequentialImpulseConstraintSolver$OrderIndex_2_classLit), Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_SolverBody_2_classLit = createForClass('com.bulletphysics.gwt.client.dynamics.constraintsolver.', 'SolverBody'), Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_SolverConstraint_2_classLit = createForClass('com.bulletphysics.gwt.client.dynamics.constraintsolver.', 'SolverConstraint'), Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_ContactSolverFunc_2_classLit = createForInterface('com.bulletphysics.gwt.client.dynamics.constraintsolver.', 'ContactSolverFunc'), _3Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_ContactSolverFunc_2_classLit = createForArray('[Lcom.bulletphysics.gwt.client.dynamics.constraintsolver.', 'ContactSolverFunc;', Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_ContactSolverFunc_2_classLit), _3_3Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_ContactSolverFunc_2_classLit = createForArray('[[Lcom.bulletphysics.gwt.client.dynamics.constraintsolver.', 'ContactSolverFunc;', _3Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_ContactSolverFunc_2_classLit), Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_SequentialImpulseConstraintSolver_2_classLit = createForClass('com.bulletphysics.gwt.client.dynamics.constraintsolver.', 'SequentialImpulseConstraintSolver'), Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_SequentialImpulseConstraintSolver$1_2_classLit = createForClass('com.bulletphysics.gwt.client.dynamics.constraintsolver.', 'SequentialImpulseConstraintSolver$1'), Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_SolverConstraintType_2_classLit = createForEnum('com.bulletphysics.gwt.client.dynamics.constraintsolver.', 'SolverConstraintType', values_6), _3Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_SolverConstraintType_2_classLit = createForArray('[Lcom.bulletphysics.gwt.client.dynamics.constraintsolver.', 'SolverConstraintType;', Lcom_bulletphysics_gwt_client_dynamics_constraintsolver_SolverConstraintType_2_classLit), Lcom_bulletphysics_gwt_client_dynamics_DynamicsWorld_2_classLit = createForClass('com.bulletphysics.gwt.client.dynamics.', 'DynamicsWorld'), Lcom_bulletphysics_gwt_client_dynamics_DiscreteDynamicsWorld_2_classLit = createForClass('com.bulletphysics.gwt.client.dynamics.', 'DiscreteDynamicsWorld'), Lcom_bulletphysics_gwt_client_dynamics_DiscreteDynamicsWorld$InplaceSolverIslandCallback_2_classLit = createForClass('com.bulletphysics.gwt.client.dynamics.', 'DiscreteDynamicsWorld$InplaceSolverIslandCallback'), Lcom_bulletphysics_gwt_client_dynamics_DiscreteDynamicsWorld$1_2_classLit = createForClass('com.bulletphysics.gwt.client.dynamics.', 'DiscreteDynamicsWorld$1'), Lcom_bulletphysics_gwt_client_dynamics_RigidBody_2_classLit = createForClass('com.bulletphysics.gwt.client.dynamics.', 'RigidBody'), Lcom_bulletphysics_gwt_client_dynamics_RigidBodyConstructionInfo_2_classLit = createForClass('com.bulletphysics.gwt.client.dynamics.', 'RigidBodyConstructionInfo'), Lcom_bulletphysics_gwt_client_linearmath_CProfileNode_2_classLit = createForClass('com.bulletphysics.gwt.client.linearmath.', 'CProfileNode'), Lcom_bulletphysics_gwt_client_linearmath_Clock_2_classLit = createForClass('com.bulletphysics.gwt.client.linearmath.', 'Clock'), Lcom_bulletphysics_gwt_client_linearmath_DefaultMotionState_2_classLit = createForClass('com.bulletphysics.gwt.client.linearmath.', 'DefaultMotionState'), Lcom_bulletphysics_gwt_client_linearmath_Transform_2_classLit = createForClass('com.bulletphysics.gwt.client.linearmath.', 'Transform'), Lcom_bulletphysics_gwt_client_util_ArrayPool_2_classLit = createForClass('com.bulletphysics.gwt.client.util.', 'ArrayPool'), Lcom_bulletphysics_gwt_client_util_ArrayPool$IntValue_2_classLit = createForClass('com.bulletphysics.gwt.client.util.', 'ArrayPool$IntValue'), Lcom_bulletphysics_gwt_client_util_ArrayPool$1_2_classLit = createForClass('com.bulletphysics.gwt.client.util.', 'ArrayPool$1'), Lcom_bulletphysics_gwt_client_util_ArrayPool$2_2_classLit = createForClass('com.bulletphysics.gwt.client.util.', 'ArrayPool$2'), Lcom_bulletphysics_gwt_client_util_ArrayPool$3_2_classLit = createForClass('com.bulletphysics.gwt.client.util.', 'ArrayPool$3'), Lcom_bulletphysics_gwt_client_util_FactoriesHelper$1_2_classLit = createForClass('com.bulletphysics.gwt.client.util.', 'FactoriesHelper$1'), Lcom_bulletphysics_gwt_client_util_FactoriesHelper$2_2_classLit = createForClass('com.bulletphysics.gwt.client.util.', 'FactoriesHelper$2'), Lcom_bulletphysics_gwt_client_util_FactoriesHelper$3_2_classLit = createForClass('com.bulletphysics.gwt.client.util.', 'FactoriesHelper$3'), Lcom_bulletphysics_gwt_client_util_FactoriesHelper$4_2_classLit = createForClass('com.bulletphysics.gwt.client.util.', 'FactoriesHelper$4'), Lcom_bulletphysics_gwt_client_util_FactoriesHelper$5_2_classLit = createForClass('com.bulletphysics.gwt.client.util.', 'FactoriesHelper$5'), Lcom_bulletphysics_gwt_client_util_FactoriesHelper$6_2_classLit = createForClass('com.bulletphysics.gwt.client.util.', 'FactoriesHelper$6'), Lcom_bulletphysics_gwt_client_util_FactoriesHelper$7_2_classLit = createForClass('com.bulletphysics.gwt.client.util.', 'FactoriesHelper$7'), Lcom_bulletphysics_gwt_client_util_FactoriesHelper$8_2_classLit = createForClass('com.bulletphysics.gwt.client.util.', 'FactoriesHelper$8'), Lcom_bulletphysics_gwt_client_util_FactoriesHelper$9_2_classLit = createForClass('com.bulletphysics.gwt.client.util.', 'FactoriesHelper$9'), Lcom_bulletphysics_gwt_client_util_FactoriesHelper$10_2_classLit = createForClass('com.bulletphysics.gwt.client.util.', 'FactoriesHelper$10'), Lcom_bulletphysics_gwt_client_util_FactoriesHelper$11_2_classLit = createForClass('com.bulletphysics.gwt.client.util.', 'FactoriesHelper$11'), Lcom_bulletphysics_gwt_client_util_FactoriesHelper$12_2_classLit = createForClass('com.bulletphysics.gwt.client.util.', 'FactoriesHelper$12'), Lcom_bulletphysics_gwt_client_util_FactoriesHelper$13_2_classLit = createForClass('com.bulletphysics.gwt.client.util.', 'FactoriesHelper$13'), Lcom_bulletphysics_gwt_client_util_FactoriesHelper$15_2_classLit = createForClass('com.bulletphysics.gwt.client.util.', 'FactoriesHelper$15'), Lcom_bulletphysics_gwt_client_util_FactoriesHelper$16_2_classLit = createForClass('com.bulletphysics.gwt.client.util.', 'FactoriesHelper$16'), Lcom_bulletphysics_gwt_client_util_FactoriesHelper$17_2_classLit = createForClass('com.bulletphysics.gwt.client.util.', 'FactoriesHelper$17'), Lcom_bulletphysics_gwt_client_util_IntArrayList_2_classLit = createForClass('com.bulletphysics.gwt.client.util.', 'IntArrayList'), _3Ljava_lang_Object_2_classLit = createForArray('[Ljava.lang.', 'Object;', Ljava_lang_Object_2_classLit), Ljava_util_AbstractCollection_2_classLit = createForClass('java.util.', 'AbstractCollection'), Ljava_util_AbstractList_2_classLit = createForClass('java.util.', 'AbstractList'), Lcom_bulletphysics_gwt_client_util_ObjectArrayList_2_classLit = createForClass('com.bulletphysics.gwt.client.util.', 'ObjectArrayList'), Lcom_bulletphysics_gwt_client_util_ObjectPool_2_classLit = createForClass('com.bulletphysics.gwt.client.util.', 'ObjectPool'), Lcom_bulletphysics_gwt_client_util_StackList_2_classLit = createForClass('com.bulletphysics.gwt.client.util.', 'StackList'), Lcom_bulletphysics_gwt_client_util_ObjectStackList_2_classLit = createForClass('com.bulletphysics.gwt.client.util.', 'ObjectStackList'), D_classLit = createForPrimitive('', 'double'), _3D_classLit = createForArray('', '[D', D_classLit), Lcom_bulletphysics_gwt_client_vecmath_Tuple4f_2_classLit = createForClass('com.bulletphysics.gwt.client.vecmath.', 'Tuple4f'), Lcom_bulletphysics_gwt_client_vecmath_Quat4f_2_classLit = createForClass('com.bulletphysics.gwt.client.vecmath.', 'Quat4f'), Ljava_lang_Throwable_2_classLit = createForClass('java.lang.', 'Throwable'), Ljava_lang_Exception_2_classLit = createForClass('java.lang.', 'Exception'), Ljava_lang_RuntimeException_2_classLit = createForClass('java.lang.', 'RuntimeException'), Lcom_bulletphysics_gwt_client_vecmath_Vector4f_2_classLit = createForClass('com.bulletphysics.gwt.client.vecmath.', 'Vector4f'), Lcom_google_gwt_user_client_Timer_2_classLit = createForClass('com.google.gwt.user.client.', 'Timer'), Lcom_google_gwt_core_client_Scheduler_2_classLit = createForClass('com.google.gwt.core.client.', 'Scheduler'), Lcom_google_gwt_core_client_impl_SchedulerImpl_2_classLit = createForClass('com.google.gwt.core.client.impl.', 'SchedulerImpl'), Lcom_google_gwt_core_client_impl_SchedulerImpl$1_2_classLit = createForClass('com.google.gwt.core.client.impl.', 'SchedulerImpl$1'), Lcom_google_gwt_core_client_impl_SchedulerImpl$2_2_classLit = createForClass('com.google.gwt.core.client.impl.', 'SchedulerImpl$2'), Ljava_lang_StackTraceElement_2_classLit = createForClass('java.lang.', 'StackTraceElement'), _3Ljava_lang_StackTraceElement_2_classLit = createForArray('[Ljava.lang.', 'StackTraceElement;', Ljava_lang_StackTraceElement_2_classLit), Lcom_google_gwt_core_client_impl_StringBufferImpl_2_classLit = createForClass('com.google.gwt.core.client.impl.', 'StringBufferImpl'), Lcom_google_gwt_core_client_impl_StringBufferImplAppend_2_classLit = createForClass('com.google.gwt.core.client.impl.', 'StringBufferImplAppend'), Lcom_google_gwt_core_client_JavaScriptException_2_classLit = createForClass('com.google.gwt.core.client.', 'JavaScriptException'), Lcom_google_gwt_core_client_JavaScriptObject_2_classLit = createForClass('com.google.gwt.core.client.', 'JavaScriptObject$'), Lcom_google_gwt_dom_client_DOMImpl_2_classLit = createForClass('com.google.gwt.dom.client.', 'DOMImpl'), Lcom_google_gwt_dom_client_DOMImplStandard_2_classLit = createForClass('com.google.gwt.dom.client.', 'DOMImplStandard'), Lcom_google_gwt_dom_client_DOMImplMozilla_2_classLit = createForClass('com.google.gwt.dom.client.', 'DOMImplMozilla'), Ljava_lang_String_2_classLit = createForClass('java.lang.', 'String'), Lcom_google_gwt_event_shared_GwtEvent_2_classLit = createForClass('com.google.gwt.event.shared.', 'GwtEvent'), Lcom_google_gwt_event_shared_GwtEvent$Type_2_classLit = createForClass('com.google.gwt.event.shared.', 'GwtEvent$Type'), Lcom_google_gwt_event_logical_shared_CloseEvent_2_classLit = createForClass('com.google.gwt.event.logical.shared.', 'CloseEvent'), Lcom_google_gwt_event_shared_DefaultHandlerRegistration_2_classLit = createForClass('com.google.gwt.event.shared.', 'DefaultHandlerRegistration'), Lcom_google_gwt_event_shared_HandlerManager_2_classLit = createForClass('com.google.gwt.event.shared.', 'HandlerManager'), Lcom_google_gwt_event_shared_HandlerManager$HandlerRegistry_2_classLit = createForClass('com.google.gwt.event.shared.', 'HandlerManager$HandlerRegistry'), Lcom_google_gwt_event_shared_HandlerManager$1_2_classLit = createForClass('com.google.gwt.event.shared.', 'HandlerManager$1'), _3_3D_classLit = createForArray('', '[[D', _3D_classLit), Lcom_google_gwt_user_client_ui_UIObject_2_classLit = createForClass('com.google.gwt.user.client.ui.', 'UIObject'), Lcom_google_gwt_user_client_ui_Widget_2_classLit = createForClass('com.google.gwt.user.client.ui.', 'Widget'), Lcom_google_gwt_user_client_ui_Panel_2_classLit = createForClass('com.google.gwt.user.client.ui.', 'Panel'), Lcom_google_gwt_user_client_ui_ComplexPanel_2_classLit = createForClass('com.google.gwt.user.client.ui.', 'ComplexPanel'), Lcom_google_gwt_user_client_ui_AbsolutePanel_2_classLit = createForClass('com.google.gwt.user.client.ui.', 'AbsolutePanel'), _3Ljava_lang_Throwable_2_classLit = createForArray('[Ljava.lang.', 'Throwable;', Ljava_lang_Throwable_2_classLit), Lcom_google_gwt_user_client_ui_AttachDetachException_2_classLit = createForClass('com.google.gwt.user.client.ui.', 'AttachDetachException'), Lcom_google_gwt_user_client_ui_AttachDetachException$1_2_classLit = createForClass('com.google.gwt.user.client.ui.', 'AttachDetachException$1'), Lcom_google_gwt_user_client_ui_AttachDetachException$2_2_classLit = createForClass('com.google.gwt.user.client.ui.', 'AttachDetachException$2'), Lcom_google_gwt_user_client_ui_CellPanel_2_classLit = createForClass('com.google.gwt.user.client.ui.', 'CellPanel'), Lcom_google_gwt_user_client_ui_SimplePanel_2_classLit = createForClass('com.google.gwt.user.client.ui.', 'SimplePanel'), _3Lcom_google_gwt_user_client_ui_Widget_2_classLit = createForArray('[Lcom.google.gwt.user.client.ui.', 'Widget;', Lcom_google_gwt_user_client_ui_Widget_2_classLit), Lcom_google_gwt_user_client_ui_Label_2_classLit = createForClass('com.google.gwt.user.client.ui.', 'Label'), Lcom_google_gwt_user_client_ui_HTML_2_classLit = createForClass('com.google.gwt.user.client.ui.', 'HTML'), Lcom_google_gwt_user_client_ui_HasHorizontalAlignment$HorizontalAlignmentConstant_2_classLit = createForClass('com.google.gwt.user.client.ui.', 'HasHorizontalAlignment$HorizontalAlignmentConstant'), Lcom_google_gwt_user_client_ui_HasVerticalAlignment$VerticalAlignmentConstant_2_classLit = createForClass('com.google.gwt.user.client.ui.', 'HasVerticalAlignment$VerticalAlignmentConstant'), Ljava_util_ArrayList_2_classLit = createForClass('java.util.', 'ArrayList'), C_classLit = createForPrimitive('', 'char'), _3C_classLit = createForArray('', '[C', C_classLit), Lcom_google_gwt_user_client_ui_RootPanel_2_classLit = createForClass('com.google.gwt.user.client.ui.', 'RootPanel'), Lcom_google_gwt_user_client_ui_RootPanel$DefaultRootPanel_2_classLit = createForClass('com.google.gwt.user.client.ui.', 'RootPanel$DefaultRootPanel'), Lcom_google_gwt_user_client_ui_RootPanel$1_2_classLit = createForClass('com.google.gwt.user.client.ui.', 'RootPanel$1'), Lcom_google_gwt_user_client_ui_RootPanel$2_2_classLit = createForClass('com.google.gwt.user.client.ui.', 'RootPanel$2'), Lcom_google_gwt_user_client_ui_SimplePanel$1_2_classLit = createForClass('com.google.gwt.user.client.ui.', 'SimplePanel$1'), Lcom_google_gwt_user_client_ui_VerticalPanel_2_classLit = createForClass('com.google.gwt.user.client.ui.', 'VerticalPanel'), Lcom_google_gwt_user_client_ui_WidgetCollection_2_classLit = createForClass('com.google.gwt.user.client.ui.', 'WidgetCollection'), Lcom_google_gwt_user_client_ui_WidgetCollection$WidgetIterator_2_classLit = createForClass('com.google.gwt.user.client.ui.', 'WidgetCollection$WidgetIterator'), Lcom_google_gwt_user_client_CommandCanceledException_2_classLit = createForClass('com.google.gwt.user.client.', 'CommandCanceledException'), Lcom_google_gwt_user_client_CommandExecutor_2_classLit = createForClass('com.google.gwt.user.client.', 'CommandExecutor'), Lcom_google_gwt_user_client_CommandExecutor$CircularIterator_2_classLit = createForClass('com.google.gwt.user.client.', 'CommandExecutor$CircularIterator'), Lcom_google_gwt_user_client_CommandExecutor$1_2_classLit = createForClass('com.google.gwt.user.client.', 'CommandExecutor$1'), Lcom_google_gwt_user_client_CommandExecutor$2_2_classLit = createForClass('com.google.gwt.user.client.', 'CommandExecutor$2'), Lcom_google_gwt_user_client_Timer$1_2_classLit = createForClass('com.google.gwt.user.client.', 'Timer$1'), Lcom_google_gwt_user_client_Window$ClosingEvent_2_classLit = createForClass('com.google.gwt.user.client.', 'Window$ClosingEvent'), Lcom_google_gwt_user_client_Window$WindowHandlers_2_classLit = createForClass('com.google.gwt.user.client.', 'Window$WindowHandlers'), Lcom_spicesoft_o3d_test_client_JBHelloWorldEP_2_classLit = createForClass('com.spicesoft.o3d.test.client.', 'JBHelloWorldEP'), Lcom_spicesoft_o3d_test_client_JBHelloWorldEP$1_2_classLit = createForClass('com.spicesoft.o3d.test.client.', 'JBHelloWorldEP$1'), Ljava_lang_IndexOutOfBoundsException_2_classLit = createForClass('java.lang.', 'IndexOutOfBoundsException'), Ljava_lang_ArrayIndexOutOfBoundsException_2_classLit = createForClass('java.lang.', 'ArrayIndexOutOfBoundsException'), Ljava_lang_ArrayStoreException_2_classLit = createForClass('java.lang.', 'ArrayStoreException'), Ljava_lang_Number_2_classLit = createForClass('java.lang.', 'Number'), Ljava_lang_Class_2_classLit = createForClass('java.lang.', 'Class'), Ljava_lang_ClassCastException_2_classLit = createForClass('java.lang.', 'ClassCastException'), Ljava_lang_IllegalArgumentException_2_classLit = createForClass('java.lang.', 'IllegalArgumentException'), Ljava_lang_IllegalStateException_2_classLit = createForClass('java.lang.', 'IllegalStateException'), Ljava_lang_Integer_2_classLit = createForClass('java.lang.', 'Integer'), _3Ljava_lang_Integer_2_classLit = createForArray('[Ljava.lang.', 'Integer;', Ljava_lang_Integer_2_classLit), Ljava_lang_NullPointerException_2_classLit = createForClass('java.lang.', 'NullPointerException'), Ljava_lang_StringBuffer_2_classLit = createForClass('java.lang.', 'StringBuffer'), Ljava_lang_UnsupportedOperationException_2_classLit = createForClass('java.lang.', 'UnsupportedOperationException'), Ljava_util_AbstractMap_2_classLit = createForClass('java.util.', 'AbstractMap'), Ljava_util_AbstractHashMap_2_classLit = createForClass('java.util.', 'AbstractHashMap'), Ljava_util_AbstractSet_2_classLit = createForClass('java.util.', 'AbstractSet'), Ljava_util_AbstractHashMap$EntrySet_2_classLit = createForClass('java.util.', 'AbstractHashMap$EntrySet'), Ljava_util_AbstractHashMap$EntrySetIterator_2_classLit = createForClass('java.util.', 'AbstractHashMap$EntrySetIterator'), Ljava_util_AbstractMapEntry_2_classLit = createForClass('java.util.', 'AbstractMapEntry'), Ljava_util_AbstractHashMap$MapEntryNull_2_classLit = createForClass('java.util.', 'AbstractHashMap$MapEntryNull'), Ljava_util_AbstractHashMap$MapEntryString_2_classLit = createForClass('java.util.', 'AbstractHashMap$MapEntryString'), Ljava_util_AbstractList$IteratorImpl_2_classLit = createForClass('java.util.', 'AbstractList$IteratorImpl'), Ljava_util_AbstractMap$1_2_classLit = createForClass('java.util.', 'AbstractMap$1'), Ljava_util_AbstractMap$1$1_2_classLit = createForClass('java.util.', 'AbstractMap$1$1'), Ljava_util_Collections$UnmodifiableCollection_2_classLit = createForClass('java.util.', 'Collections$UnmodifiableCollection'), Ljava_util_Collections$UnmodifiableList_2_classLit = createForClass('java.util.', 'Collections$UnmodifiableList'), Ljava_util_Collections$UnmodifiableMap_2_classLit = createForClass('java.util.', 'Collections$UnmodifiableMap'), Ljava_util_Collections$UnmodifiableSet_2_classLit = createForClass('java.util.', 'Collections$UnmodifiableSet'), Ljava_util_Collections$UnmodifiableMap$UnmodifiableEntrySet_2_classLit = createForClass('java.util.', 'Collections$UnmodifiableMap$UnmodifiableEntrySet'), Ljava_util_Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntry_2_classLit = createForClass('java.util.', 'Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntry'), Ljava_util_Collections$UnmodifiableMap$UnmodifiableEntrySet$1_2_classLit = createForClass('java.util.', 'Collections$UnmodifiableMap$UnmodifiableEntrySet$1'), Ljava_util_Collections$UnmodifiableRandomAccessList_2_classLit = createForClass('java.util.', 'Collections$UnmodifiableRandomAccessList'), Ljava_util_Collections$UnmodifiableCollectionIterator_2_classLit = createForClass('java.util.', 'Collections$UnmodifiableCollectionIterator'), Ljava_util_Comparators$1_2_classLit = createForClass('java.util.', 'Comparators$1'), Ljava_util_HashMap_2_classLit = createForClass('java.util.', 'HashMap'), Ljava_util_HashSet_2_classLit = createForClass('java.util.', 'HashSet'), Ljava_util_MapEntryImpl_2_classLit = createForClass('java.util.', 'MapEntryImpl'), Ljava_util_NoSuchElementException_2_classLit = createForClass('java.util.', 'NoSuchElementException');
$stats && $stats({moduleName:'JBHelloWorld',sessionId:$sessionId,subSystem:'startup',evtGroup:'moduleStartup',millis:(new Date()).getTime(),type:'moduleEvalEnd'});
if ($wnd.JBHelloWorld) $wnd.JBHelloWorld.onScriptLoad();
--></script></body></html>
